Sopprimere l'avviso "La categoria sta implementando un metodo che verrà implementato anche dalla sua classe primaria"

Mi chiedevo come sopprimere l'avviso:

Category sta implementando un metodo che sarà implementato anche dalla sua classe primaria.

Ho questo per una categoria di codice specifica:

+ (UIFont *)systemFontOfSize:(CGFloat)fontSize {
    return [self aCustomFontOfSize:fontSize];
}

Una categoria consente di aggiungere nuovi metodi a una classe esistente. Se desideri reimplementare un metodo già esistente nella classe, in genere crei una sottoclasse invece di una categoria.

Documentazione Apple: personalizzazione delle classi esistenti

Se il nome di un metodo dichiarato in una categoria è lo stesso di un metodo nella classe originale, o di un metodo in un'altra categoria sulla stessa classe (o anche una superclasse), il comportamento è indefinito per quanto riguarda l'implementazione del metodo utilizzata in runtime.

Due metodi con la stessa identica firma nella stessa classe porterebbero a un comportamento imprevedibile, perché ogni chiamante non può specificare quale implementazione desidera.

Quindi, dovresti usare una categoria e fornire nomi di metodo nuovi e univoci per la classe, o una sottoclasse se vuoi cambiare il comportamento di un metodo esistente in una classe.

Sebbene tutto ciò che bneely detto sia corretto, in realtà non risponde alla tua domanda su come sopprimere l'avvertimento.

Se devi inserire questo codice per qualche motivo (nel mio caso ho HockeyKit nel mio progetto e sovrascrivono un metodo in una categoria UIImage [modifica: non è più il caso]) e devi far compilare il tuo progetto , puoi utilizzare le #pragmaistruzioni per bloccare l'avviso in questo modo:

#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wobjc-protocol-method-implementation"

// do your override

#pragma clang diagnostic pop

Ho trovato le informazioni qui: http://www.cocoabuilder.com/archive/xcode/313767-disable-warning-for-override-in-category.html

Un'alternativa migliore (vedi la risposta di bneely al motivo per cui questo avviso ti sta salvando dal disastro) è usare il metodo swizzling. Utilizzando il metodo swizzling, è possibile sostituire un metodo esistente da una categoria senza l'incertezza di chi "vince" e preservando la capacità di richiamare il vecchio metodo. Il segreto è dare all'override un nome di metodo diverso, quindi scambiarli usando le funzioni di runtime.

#import <objc/runtime.h> 
#import <objc/message.h>

void MethodSwizzle(Class c, SEL orig, SEL new) {
    Method origMethod = class_getInstanceMethod(c, orig);
    Method newMethod = class_getInstanceMethod(c, new);
    if(class_addMethod(c, orig, method_getImplementation(newMethod), method_getTypeEncoding(newMethod)))
        class_replaceMethod(c, new, method_getImplementation(origMethod), method_getTypeEncoding(origMethod));
    else
    method_exchangeImplementations(origMethod, newMethod);
}

Quindi definisci la tua implementazione personalizzata:

+ (UIFont *)mySystemFontOfSize:(CGFloat)fontSize {
...
}

Sostituisci l'implementazione predefinita con la tua:

MethodSwizzle([UIFont class], @selector(systemFontOfSize:), @selector(mySystemFontOfSize:));

Prova questo nel tuo codice:

+(void)load{
    EXCHANGE_METHOD(Method1, Method1Impl);
}

AGGIORNAMENTO2: aggiungi questa macro

#import <Foundation/Foundation.h>
#define EXCHANGE_METHOD(a,b) [[self class]exchangeMethod:@selector(a) withNewMethod:@selector(b)]

@interface NSObject (MethodExchange)
+(void)exchangeMethod:(SEL)origSel withNewMethod:(SEL)newSel;
@end

#import <objc/runtime.h>

@implementation NSObject (MethodExchange)

+(void)exchangeMethod:(SEL)origSel withNewMethod:(SEL)newSel{
    Class class = [self class];

    Method origMethod = class_getInstanceMethod(class, origSel);
    if (!origMethod){
        origMethod = class_getClassMethod(class, origSel);
    }
    if (!origMethod)
        @throw [NSException exceptionWithName:@"Original method not found" reason:nil userInfo:nil];
    Method newMethod = class_getInstanceMethod(class, newSel);
    if (!newMethod){
        newMethod = class_getClassMethod(class, newSel);
    }
    if (!newMethod)
        @throw [NSException exceptionWithName:@"New method not found" reason:nil userInfo:nil];
    if (origMethod==newMethod)
        @throw [NSException exceptionWithName:@"Methods are the same" reason:nil userInfo:nil];
    method_exchangeImplementations(origMethod, newMethod);
}

@end

È possibile utilizzare il metodo swizzling per sopprimere questo avviso del compilatore. Ecco come ho implementato il metodo swizzling per disegnare i margini in un UITextField quando usiamo uno sfondo personalizzato con UITextBorderStyleNone:

#import <UIKit/UIKit.h>

@interface UITextField (UITextFieldCatagory)

+(void)load;
- (CGRect)textRectForBoundsCustom:(CGRect)bounds;
- (CGRect)editingRectForBoundsCustom:(CGRect)bounds;
@end

#import "UITextField+UITextFieldCatagory.h"
#import <objc/objc-runtime.h>

@implementation UITextField (UITextFieldCatagory)

+(void)load
{
    Method textRectForBounds = class_getInstanceMethod(self, @selector(textRectForBounds:));
    Method textRectForBoundsCustom = class_getInstanceMethod(self, @selector(textRectForBoundsCustom:));

    Method editingRectForBounds = class_getInstanceMethod(self, @selector(editingRectForBounds:));
    Method editingRectForBoundsCustom = class_getInstanceMethod(self, @selector(editingRectForBoundsCustom:));


    method_exchangeImplementations(textRectForBounds, textRectForBoundsCustom);
    method_exchangeImplementations(editingRectForBounds, editingRectForBoundsCustom);

}


- (CGRect)textRectForBoundsCustom:(CGRect)bounds
{
    CGRect inset = CGRectMake(bounds.origin.x + 10, bounds.origin.y, bounds.size.width - 10, bounds.size.height);
    return inset;
}

- (CGRect)editingRectForBoundsCustom:(CGRect)bounds
{
    CGRect inset = CGRectMake(bounds.origin.x + 10, bounds.origin.y, bounds.size.width - 10, bounds.size.height);
    return inset;
}

@end

Le proprietà over-riding sono valide per un'estensione di classe (categoria anonima), ma non per una categoria normale.

Secondo Apple Docs utilizzando un'estensione di classe (categoria anonima) è possibile creare un'interfaccia privata per una classe pubblica, in modo tale che l'interfaccia privata possa sovrascrivere le proprietà esposte pubblicamente. cioè puoi cambiare una proprietà da readonly a readwrite.

Un caso d'uso per questo è quando si scrivono librerie che limitano l'accesso alle proprietà pubbliche, mentre la stessa proprietà richiede l'accesso completo in lettura e scrittura all'interno della libreria.

Collegamento a Apple Docs: https://developer.apple.com/library/ios/documentation/Cocoa/Conceptual/ProgrammingWithObjectiveC/CustomizingExistingClasses/CustomizingExistingClasses.html

Cerca " Usa estensioni di classe per nascondere le informazioni private ".

Quindi questa tecnica è valida per un'estensione di classe, ma non per una categoria.

Le categorie sono una buona cosa, ma possono essere abusate. Quando scrivi le categorie, dovresti come principio NON reimplementare i metodi in uscita. Ciò potrebbe causare strani effetti collaterali poiché ora stai riscrivendo il codice che dipende da un'altra classe. potresti rompere una classe conosciuta e finire per ribaltare il tuo debugger. È semplicemente una cattiva programmazione.

Se hai bisogno di farlo, dovresti davvero sottoclassarlo.

Poi il suggerimento di swizzling, che è un grande NO-NO-NO per me.

Swizzing in fase di esecuzione è un completo NO-NO-NO.

Vuoi che una banana assomigli a un'arancia, ma solo in fase di esecuzione? Se vuoi un'arancia, scrivi un'arancia.

Non fare l'aspetto di una banana e agire come un'arancia. E peggio: non trasformare la tua banana in un agente segreto che saboterà silenziosamente le banane in tutto il mondo a sostegno delle arance.

Yikes!

Ho avuto questo problema quando ho implementato un metodo delegato in una categoria piuttosto che nella classe principale (anche se non c'era l'implementazione della classe principale). La soluzione per me era spostare dal file di intestazione della classe principale al file di intestazione della categoria. Funziona bene