¿De qué se trata @synthesize foo = _foo?

Question

¿Por qué uno quiere este prefijo de subrayado en una aplicación de iOS?

Answer 1

es una convención para mantener el ivar (variables de instancia) seguro, por lo que solo se puede acceder a través de getter y setter.

Answer 2

He aquí por qué hago esto a veces:

Si yo quiero hacer la carga diferida en una propiedad típicamente Voy a subrayar mi Ivar por lo que el trabajo realizado para cargar los datos deseados desde el servidor back-end/guardados file/what-have-you solo se carga la primera vez. Por ejemplo:

- (NSMutableArray *)recentHistory; 
{ 
    if (_recentHistory == nil) 
    { 
     // Get it and set it, otherwise no work is needed... hooray! 
    } 

    return _recentHistory; 
} 

Así que aquí llama a la propiedad [instanceOfClass recentHistory] (o instanceOfClass.recentHistory) comprobará el Ivar para ver si se necesita para cargar los datos o simplemente devolver los datos ya cargados.

Es excesivo declarar todas sus propiedades de esta manera.

Espero que ayude.

Answer 3

A veces es útil ver qué sucede detrás de las escenas para comprender. Básicamente cuando vea este

@property (nonatomic, retain) Foo *foo; 

Con esto en la puesta en práctica

@synthesize foo=_foo; 

Es el azúcar sintaxis para el siguiente, lo que significa que el compilador básicamente genera el código para usted

Foo *foo = nil; 

-(Foo *) foo { 
    return _foo; 
} 

-(void) setFoo:(Foo *)val { 
    if(_foo != val) { 
     [_foo release]; 
     _foo = [val retain]; 
    } 
} 

esta manera cuando se refiere a la propiedad pública, la golpea a través de los accesorios generados en self.foo y si desea consultar el variable de instancia dentro de su clase puede consultar _foo. Antes de XCode cuatro, era fácil confundirse entre los dos. Podría hacer algo como

self.foo = foo1; 

foo = foo2; 

Esto era perfectamente legal y podría causar problemas en un par de niveles. La segunda línea no usa el acceso, por lo que no se conservará foo2, lo que podría ocasionar que la recolección de basura la recoja prematuramente. Peor aún, la segunda línea no utiliza el acceso que liberaría ningún valor anterior, lo que significa que podría causar una pérdida de memoria.

Por lo tanto, en resumen, la nueva técnica crea un getter y un setter para su propiedad y le permite especificar también el nombre que se utilizará para la variable de instancia, utilizada para la encapsulación.

Answer 4

solo quería agregar mis pensamientos a todas las respuestas anteriores.

en mi caso, lo uso principalmente para mantener mis clases a salvo de accidentes.

en mis archivos .h, declaro solo las propiedades sin ivars. en el archivo .m, utilizo el patrón @synthesize anterior para ocultar el ivar real de los usuarios, incluyéndome a mí, forzado a usar los accesadores sintetizados/dinámicos y no los ivars directamente. podría usar cualquier cosa para su nombre y no solo subrayarlo. p.ej.usted podría hacer:

@synthesize foo = _mySecretFoo; 
@synthesize bar = oneUglyVarBecauseIHateMyBoss; 

esta manera, su jefe sólo se vería bar, y que le resultará mucho más fácil, más seguro y por lo tanto, utilizar el descriptor de acceso de barras - si se utiliza la notación o mensajes de puntos.

prefiero este enfoque sobre el otro,

@property (getter=foo, setter=setFoo, ...) _mySecretFoo; 
@property (getter=bar, setter=setBar, ...) oneUglyVarBecauseIHateMyBoss; 

ya que esto no hace cumplir implementación privada y la encapsulación, y es simplemente escribiendo extra cuando Xcode puede hacer lo mismo para usted. Una cosa para recordar, ¡las propiedades no son lo mismo que ivars! podrías tener más propiedades que ivars, o al revés.