UIAppearance proxy für benutzerdefinierte Objekte

Nach einigen Forschung ich "aufgeben" über die Verwendung einer standard-Apple-Objekt. Es nicht vorhanden ist, für jetzt. Ich habe meinen eigenen proxy, es ist ganz einfach (funktioniert nur mit "Aussehen:" von jetzt).

Lassen Sie uns erklären Sie.
Ich möchte festlegen, das Erscheinungsbild der "Textfarbe" auf ein NSObject Unterklasse, nennen wir es mal "FLObject".
Machen FLObject entspricht UIAppearance Protokoll und überschreiben Sie die Methode Aussehen.
In dieser Methode sollten Sie wieder eine proxy-Klasse (die ich erstellt):

+ (id)appearance
{
    return [FLAppearance appearanceForClass:[self class]];
}

Wie es funktioniert?
FLAppearance erstellt eine einzelne Instanz von sich selbst, für jede Klasse übergeben, die von der appearanceForClass: Methode.
Wenn rufen Sie es zwei mal für die gleiche Klasse, die gleiche Instanz zurückgegeben.

Dann können Sie etwas wie das hier tun:

[[FLObject appearance] setTextColor:[UIColor redColor]]; 

FLAppearance überschreibt die forwardInvocation: Methode, so dass es akzeptiert alle Methoden gesendet.
Dann, es setzt alle Aufrufe in einem array.
Wenn FLObject initialisiert wird, ein einfacher Aufruf

[(FLAppearance *)[FLAppearance appearanceForClass:[self class]] startForwarding:self];

beginnt zu senden, Anrufungen und legen Sie die Anzeige.
Sicher, das braucht etwas tuning und Fehler überprüfen, aber ich denke, es ist ein guter Anfang.

@interface FLAppearance ()

@property (strong, nonatomic) Class mainClass;
@property (strong, nonatomic) NSMutableArray *invocations;

@end

static NSMutableDictionary *dictionaryOfClasses = nil;

@implementation FLAppearance

//this method return the same object instance for each different class
+ (id) appearanceForClass:(Class)thisClass
{
    //create the dictionary if not exists
    //use a dispatch to avoid problems in case of concurrent calls
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        if (!dictionaryOfClasses)
            dictionaryOfClasses = [[NSMutableDictionary alloc]init];
    });



    if (![dictionaryOfClasses objectForKey:NSStringFromClass(thisClass)])
    {
        id thisAppearance = [[self alloc]initWithClass:thisClass];
        [dictionaryOfClasses setObject:thisAppearance forKey:NSStringFromClass(thisClass)];
        return thisAppearance;
    }
    else
        return [dictionaryOfClasses objectForKey:NSStringFromClass(thisClass)];
}

- (id)initWithClass:(Class)thisClass
{
    self = [self initPrivate];
    if (self) {
        self.mainClass = thisClass;
        self.invocations = [NSMutableArray array];
    }
    return self;
}

- (id)init
{
    [NSException exceptionWithName:@"InvalidOperation" reason:@"Cannot invoke init. Use appearanceForClass: method" userInfo:nil];
    return nil;
}

- (id)initPrivate
{
    if (self = [super init]) {

    }
    return self;
}

-(void)forwardInvocation:(NSInvocation *)anInvocation;
{
    //tell the invocation to retain arguments
    [anInvocation retainArguments];

    //add the invocation to the array
    [self.invocations addObject:anInvocation];
}

- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector {
    return [self.mainClass instanceMethodSignatureForSelector:aSelector];
}

-(void)startForwarding:(id)sender
{
    for (NSInvocation *invocation in self.invocations) {
        [invocation setTarget:sender];
        [invocation invoke];
    }
}

Schöne Umsetzung, die ich leicht modifiziert den code und erstellt die Klasse als eine Unterklasse von NSProxy. Verwenden Sie es in einem Projekt fand ich ein memory-leak:

Beispiel: mit dem proxy, in der Globale Einstellungen/Aussehen, jede Instanz dieser Klasse nie erreichen wird refCount auf 0, so dass dealloc wird nie aufgerufen werden.

Leck-code:

-(void)forwardInvocation:(NSInvocation *)anInvocation;
{
    [...]

    //!! This will retain also the target

    [anInvocation retainArguments];

    [...]
}

Update:

-(void)forwardInvocation:(NSInvocation *)anInvocation
{
     [anInvocation setTarget:nil];
     [anInvocation retainArguments];

     //add the invocation to the array
     [self.invocations addObject:anInvocation];
}

-(void)startForwarding:(id)sender
{
     for (NSInvocation *invocation in self.invocations) {

         //Create a new copy of the stored invocation,
         //otherwise setting the new target, this will never be released
         //because the invocation in the array is still alive after the call

         NSInvocation *targetInvocation = [invocation copy];
         [targetInvocation setTarget:sender];
         [targetInvocation invoke];
         targetInvocation = nil;
     }
}

Kategorie kopieren für NSInvocation

-(id)copy
{
     NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:[self methodSignature]];
     NSUInteger numberOfArguments = [[self methodSignature] numberOfArguments];

     [invocation setTarget:self.target];
     [invocation setSelector:self.selector];

     if (numberOfArguments > 2) {
         for (int i = 0; i < (numberOfArguments - 2); i++) {
             char buffer[sizeof(intmax_t)];
             [self getArgument:(void *)&buffer atIndex:i + 2];
             [invocation setArgument:(void *)&buffer atIndex:i + 2];
         }
     }

     return invocation;
}