Supprimer l'avertissement "La catégorie met en œuvre une méthode qui sera également implémentée par sa classe principale"

Je me demandais comment supprimer l'avertissement:

Category met en œuvre une méthode qui sera également implémentée par sa classe primaire.

J'ai ceci pour une catégorie de code spécifique:

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

Une catégorie vous permet d'ajouter de nouvelles méthodes à une classe existante. Si vous souhaitez réimplémenter une méthode qui existe déjà dans la classe, vous créez généralement une sous-classe au lieu d'une catégorie.

Documentation Apple: Personnalisation des classes existantes

Si le nom d'une méthode déclarée dans une catégorie est le même qu'une méthode dans la classe d'origine, ou une méthode dans une autre catégorie sur la même classe (ou même une superclasse), le comportement n'est pas défini quant à l'implémentation de méthode utilisée à Durée.

Deux méthodes avec exactement la même signature dans la même classe entraîneraient un comportement imprévisible, car chaque appelant ne peut pas spécifier l'implémentation qu'il souhaite.

Par conséquent, vous devez soit utiliser une catégorie et fournir des noms de méthode nouveaux et uniques pour la classe, soit une sous-classe si vous souhaitez modifier le comportement d'une méthode existante dans une classe.

Bien que tout ce qui a été dit est correct, cela ne répond pas réellement à votre question de savoir comment supprimer l'avertissement.

Si vous devez avoir ce code pour une raison quelconque (dans mon cas, j'ai HockeyKit dans mon projet et ils remplacent une méthode dans une catégorie UIImage [modifier: ce n'est plus le cas]) et vous devez obtenir votre projet pour compiler , vous pouvez utiliser des #pragmainstructions pour bloquer l'avertissement comme ceci:

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

// do your override

#pragma clang diagnostic pop

J'ai trouvé les informations ici: http://www.cocoabuilder.com/archive/xcode/313767-disable-warning-for-override-in-category.html

Une meilleure alternative (voir la réponse de bneely à la raison pour laquelle cet avertissement vous sauve du désastre) est d'utiliser la méthode swizzling. En utilisant la méthode swizzling, vous pouvez remplacer une méthode existante à partir d'une catégorie sans l'incertitude de savoir qui "gagne", et tout en préservant la possibilité de faire appel à l'ancienne méthode. Le secret est de donner au remplacement un nom de méthode différent, puis de les échanger à l'aide des fonctions d'exécution.

#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);
}

Définissez ensuite votre implémentation personnalisée:

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

Remplacez l'implémentation par défaut par la vôtre:

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

Essayez ceci dans votre code:

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

UPDATE2: ajouter cette 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

Vous pouvez utiliser la méthode swizzling pour supprimer cet avertissement du compilateur. Voici comment j'ai implémenté la méthode swizzling pour dessiner des marges dans un UITextField lorsque nous utilisons un arrière-plan personnalisé avec 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

Les propriétés de remplacement sont valides pour une extension de classe (catégorie anonyme), mais pas pour une catégorie standard.

Selon Apple Docs, à l'aide d'une extension de classe (catégorie anonyme), vous pouvez créer une interface privée vers une classe publique, de sorte que l'interface privée puisse remplacer les propriétés exposées publiquement. c'est-à-dire que vous pouvez changer une propriété de readonly à readwrite.

Un cas d'utilisation pour cela est lorsque vous écrivez des bibliothèques qui restreignent l'accès aux propriétés publiques, alors que la même propriété nécessite un accès complet en lecture et en écriture dans la bibliothèque.

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

Recherchez « Utiliser les extensions de classe pour masquer les informations privées ».

Cette technique est donc valable pour une extension de classe, mais pas pour une catégorie.

Les catégories sont une bonne chose, mais elles peuvent être abusées. Lorsque vous écrivez des catégories, vous ne devez en principe PAS réimplémenter les méthodes existantes. Cela peut provoquer un effet secondaire étrange car vous réécrivez maintenant du code dont une autre classe dépend. vous pourriez casser une classe connue et finir par retourner votre débogueur. C'est simplement une mauvaise programmation.

Si vous avez besoin de le faire, vous devriez vraiment le sous-classer.

Puis la suggestion de swizzling, c'est un grand NON-NON-NON pour moi.

Le swizzing au moment de l'exécution est un NO-NO-NO complet.

Vous voulez qu'une banane ressemble à une orange, mais seulement à l'exécution? Si vous voulez une orange, écrivez une orange.

Ne faites pas une banane et n'agissez pas comme une orange. Et pire: ne transformez pas votre banane en un agent secret qui sabotera tranquillement les bananes du monde entier pour soutenir les oranges.

Yikes!

J'ai eu ce problème lorsque j'ai implémenté une méthode déléguée dans une catégorie plutôt que dans la classe principale (même s'il n'y avait pas d'implémentation de classe principale). La solution pour moi était de déplacer le fichier d'en-tête de classe principal vers le fichier d'en-tête de catégorie Cela fonctionne très bien