Unikaj dodatkowych zmiennych statycznych dla powiązanych kluczy obiektów

Jeśli potrzebujesz dostępu do klucza spoza zakresu pojedynczej metody, dobrym wzorcem dla tego, co prowadzi do bardziej czytelnego kodu, jest utworzenie wskaźnika, który po prostu wskazuje na swój własny adres w stosie. Na przykład:

static void const *MyAssocKey = &MyAssocKey;

Jeśli tylko potrzebujesz dostępu z zakresu jednej metody, możesz po prostu użyć _cmd, która jest gwarantowana jako unikalna. Na przykład:

objc_setAssociatedObject(obj, _cmd, associatedObj, OBJC_ASSOCIATION_RETAIN_NONATOMIC);

Lekką wariacją na temat omawianego pomysłu @ Gabriele Petronella jest przypisanie słownika do każdego obiektu:

//NSObject+ADDLAssociatedDictionary.h

#import <Foundation/Foundation.h>

@interface NSObject (ADDLAssociatedDictionary)
- (void)addl_setAssociatedObject:(id)object forKey:(id<NSCopying>)key;
- (id)addl_associatedObjectForKey:(id<NSCopying>)key;
@end

//NSObject+ADDLAssociatedDictionary.m

#import <objc/runtime.h>

@interface NSObject (ADDLAssociatedDictionaryInternal)
- (NSMutableDictionary *)addl_associatedDictionary;
@end

@implementation NSObject (ADDLAssociatedDictionary)

- (void)addl_setAssociatedObject:(id)object forKey:(id<NSCopying>)key
{
    if (object) {
        self.addl_associatedDictionary[key] = object;
    } else {
        [self.addl_associatedDictionary removeObjectForKey:key];
    }
}
- (id)addl_associatedObjectForKey:(id<NSCopying>)key
{
    return self.addl_associatedDictionary[key];
}

@end

@implementation NSObject (ADDLAssociatedDictionaryInternal)
const char addl_associatedDictionaryAssociatedObjectKey;
- (NSMutableDictionary *)addl_associatedDictionaryPrimitive
{
    return objc_getAssociatedObject(self, &addl_associatedDictionaryAssociatedObjectKey);
}
- (void)addl_setAssociatedDictionaryPrimitive:(NSMutableDictionary *)associatedDictionary
{
    objc_setAssociatedObject(self, &addl_associatedDictionaryAssociatedObjectKey, associatedDictionary, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}
- (NSMutableDictionary *)addl_generateAssociatedDictionary
{
    NSMutableDictionary *associatedDictionary = [[NSMutableDictionary alloc] init];
    [self addl_setAssociatedDictionaryPrimitive:associatedDictionary];
    return associatedDictionary;
}

- (NSMutableDictionary *)addl_associatedDictionary
{
    NSMutableDictionary *res = nil;

    @synchronized(self) {
        if (!(res = [self addl_associatedDictionaryPrimitive])) {
            res = [self addl_generateAssociatedDictionary];
        }
    }

    return res;
}
@end

Następnie w naszej kategorii na jakiejś podklasie wywodzącej się z NSObject

//Derived+Additions.h

#import "Derived.h"

@interface Derived (Additions)
@property (nonatomic) id anAssociatedObject;
@end

//Derived+Additions.m

#import "NSObject+ADDLAssociatedDictionary.h"

@implementation Derived (Additions)
- (void)setAnAssociatedObject:(id)anAssociatedObject
{
    [self addl_setAssociatedObject:anAssociatedObject forKey:NSStringFromSelector(@selector(anAssociatedObject))];
}
- (id)anAssociatedObject
{
    return [self addl_associatedObjectForKey:NSStringFromSelector(@selector(anAssociatedObject))];
}
@end

Jedną z zalet skojarzonego podejścia słownikowego jest zwiększona elastyczność, która wynika z możliwości ustawiania obiektów dla kluczy generowanych w czasie wykonywania, nie wspominając o znacznie ładniejszej składni.

A korzyść szczególna w stosowaniu

NSStringFromSelector(@selector(anAssociatedObject))

Czy to NSStringFromSelector jest gwarantowane, aby dać NSString reprezentację selektora, który zawsze będzie akceptowalnym kluczem słownikowym. W związku z tym nie musimy się wcale martwić (choć nie sądzę, że jest to uzasadniona troska) o zmiany ABI.