@synthesize vs @dynamic, quali sono le differenze?

Quali sono le differenze tra l'implementazione di un @propertycon @dynamico @synthesize?

@synthesize genererà metodi getter e setter per la tua proprietà. @dynamic dice al compilatore che i metodi getter e setter non sono implementati dalla classe stessa ma da qualche altra parte (come la superclasse o saranno forniti in fase di esecuzione).

Gli usi di @dynamic sono ad es. Con sottoclassi di NSManagedObject(CoreData) o quando si desidera creare un outlet per una proprietà definita da una superclasse che non è stata definita come outlet.

@dynamic può anche essere usato per delegare la responsabilità dell'implementazione degli accessor. Se implementi tu stesso gli accessori all'interno della classe, normalmente non usi @dynamic.

Classe eccellente:

@property (nonatomic, retain) NSButton *someButton;
...
@synthesize someButton;

sottoclasse:

@property (nonatomic, retain) IBOutlet NSButton *someButton;
...
@dynamic someButton;

Dai un'occhiata a questo articolo ; sotto la voce "Metodi forniti in fase di esecuzione":

Alcuni accessori vengono creati dinamicamente in fase di runtime, come alcuni utilizzati nella classe NSManagedObject di CoreData. Se si desidera dichiarare e utilizzare le proprietà per questi casi, ma si desidera evitare avvisi sui metodi mancanti in fase di compilazione, è possibile utilizzare la direttiva @dynamic anziché @synthesize.

...

L'uso della direttiva @dynamic in sostanza dice al compilatore "non preoccuparti, è in arrivo un metodo".

La @synthesizedirettiva, d'altra parte, genera i metodi di accesso per te in fase di compilazione (sebbene, come notato nella sezione "Miscelazione di accessori sintetizzati e personalizzati", è flessibile e non genera metodi per te se entrambi sono implementati).

Come altri hanno già detto, in generale usi @synthesize per fare in modo che il compilatore generi i getter e / o le impostazioni per te, e @dynamic se hai intenzione di scriverli tu stesso.

C'è un'altra sottigliezza non ancora menzionata: @synthesize ti consentirà di implementare tu stesso un getter o un setter. Ciò è utile se si desidera implementare il getter solo per qualche logica aggiuntiva, ma lasciare che il compilatore generi il setter (che, per gli oggetti, di solito è un po 'più complesso da scrivere).

Tuttavia, se si scrive un'implementazione per un accessor @ synthesize, deve comunque essere supportato da un campo reale (ad esempio, se si scrive -(int) getFoo();è necessario disporre di un int foo;campo). Se il valore viene prodotto da qualcos'altro (ad es. Calcolato da altri campi), devi usare @dynamic.

@dynamic è generalmente usato (come è stato detto sopra) quando una proprietà viene creata dinamicamente in fase di esecuzione. NSManagedObject fa questo (perché tutte le sue proprietà sono dinamiche) - che elimina alcuni avvisi del compilatore.

Per una buona panoramica su come creare proprietà dinamicamente (senza NSManagedObject e CoreData :, vedere: http://developer.apple.com/library/ios/#documentation/Cocoa/Conceptual/ObjCRuntimeGuide/Articles/ocrtDynamicResolution.html#// apple_ref / doc / uid / TP40008048-CH102-SW1

ecco un esempio di @dinamico

#import <Foundation/Foundation.h>

@interface Book : NSObject
{
   NSMutableDictionary *data;
}
@property (retain) NSString *title;
@property (retain) NSString *author;
@end

@implementation Book
@dynamic title, author;

- (id)init
{
    if ((self = [super init])) {
        data = [[NSMutableDictionary alloc] init];
        [data setObject:@"Tom Sawyer" forKey:@"title"];
        [data setObject:@"Mark Twain" forKey:@"author"];
    }
    return self;
}

- (void)dealloc
{
    [data release];
    [super dealloc];
}

- (NSMethodSignature *)methodSignatureForSelector:(SEL)selector
{
    NSString *sel = NSStringFromSelector(selector);
    if ([sel rangeOfString:@"set"].location == 0) {
        return [NSMethodSignature signatureWithObjCTypes:"v@:@"];
    } else {
        return [NSMethodSignature signatureWithObjCTypes:"@@:"];
    }
 }

- (void)forwardInvocation:(NSInvocation *)invocation
{
    NSString *key = NSStringFromSelector([invocation selector]);
    if ([key rangeOfString:@"set"].location == 0) {
        key = [[key substringWithRange:NSMakeRange(3, [key length]-4)] lowercaseString];
        NSString *obj;
        [invocation getArgument:&obj atIndex:2];
        [data setObject:obj forKey:key];
    } else {
        NSString *obj = [data objectForKey:key];
        [invocation setReturnValue:&obj];
    }
}

@end

int main(int argc, char **argv)
{
    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];

    Book *book = [[Book alloc] init];
    printf("%s is written by %s\n", [book.title UTF8String], [book.author UTF8String]);
    book.title = @"1984";
    book.author = @"George Orwell";
    printf("%s is written by %s\n", [book.title UTF8String], [book.author UTF8String]);

   [book release];
   [pool release];
   return 0;
}

Secondo la documentazione:

https://developer.apple.com/library/mac/documentation/cocoa/conceptual/ObjCRuntimeGuide/Articles/ocrtDynamicResolution.html

@dynamic dice al compilatore che i metodi di accesso sono forniti in fase di esecuzione.

Con un po 'di indagine ho scoperto che fornire metodi di accesso ha la precedenza sulla direttiva @dynamic.

@synthesize dice al compilatore di creare quegli accessor per te (getter e setter)

@property dice al compilatore che gli accessor verranno creati e a cui è possibile accedere con la notazione punto o [messaggio oggetto]

Una cosa da aggiungere è che se una proprietà viene dichiarata come @dinamica non occuperà memoria (ho confermato con lo strumento di allocazione). Una conseguenza è che puoi dichiarare la proprietà nella categoria di classe.

Come da documentazione Apple.

Si utilizza l' @synthesizeistruzione nel blocco di implementazione di una classe per indicare al compilatore di creare implementazioni che corrispondono alla specifica fornita nella @propertydichiarazione.

Utilizzare l' @dynamicistruzione per indicare al compilatore di sopprimere un avviso se non riesce a trovare un'implementazione dei metodi di accesso specificati da una @propertydichiarazione.

Ulteriori informazioni:-

https://developer.apple.com/library/ios/documentation/General/Conceptual/DevPedia-CocoaCore/DeclaredProperty.html