@property conserve, atsortingbue, copie, nonatomique en Objective-C

L’article lié à MrMage ne fonctionne plus. Donc, voici ce que j’ai appris dans mon (très) court temps de codage en Objective-C:

nonatomique vs atomique – “atomique” est la valeur par défaut. Toujours utiliser “nonatomique”. Je ne sais pas pourquoi, mais le livre que j’ai lu disait qu’il y avait “rarement une raison” d’utiliser “l’atome”. (BTW: Le livre que j’ai lu est le livre BNR “iOS Programming”.)

readwrite vs. readonly – “readwrite” est la valeur par défaut. Lorsque vous synthétisez, un getter et un setter seront créés pour vous. Si vous utilisez “readonly”, aucun setter ne sera créé. Utilisez-le pour une valeur que vous ne voulez pas changer après l’instanciation de l’object.

conserver vs copie vs assigner

• “assigner” est la valeur par défaut. Dans le setter créé par @synthesize, la valeur sera simplement affectée à l’atsortingbut. Ma compréhension est que “assign” devrait être utilisé pour les atsortingbuts non-pointeur.
• “retain” est nécessaire lorsque l’atsortingbut est un pointeur sur un object. Le setter généré par @synthesize conservera (aka appenda un compte de réserve) l’object. Vous devrez libérer l’object lorsque vous en aurez fini.
• “copie” est nécessaire lorsque l’object est mutable. Utilisez cette option si vous avez besoin de la valeur de l’object à ce stade et que vous ne souhaitez pas que cette valeur reflète les modifications apscopes par d’autres propriétaires de l’object. Vous devrez libérer l’object lorsque vous en aurez fini car vous en conservez la copie.

Avant de connaître les atsortingbuts de @property, vous devez savoir quelle est l’utilisation de @property.

• @property offre un moyen de définir les informations qu’une classe est destinée à encapsuler. Si vous déclarez un object / variable à l’aide de @property , cet object / variable sera accessible aux autres classes important sa classe.

• Si vous déclarez un object à l’aide de @property dans le fichier d’en-tête, vous devez le synthétiser à l’aide de @synthesize dans le fichier d’implémentation. Cela rend l’object KVC conforme . Par défaut, le compilateur synthétisera les méthodes d’ access pour cet object.

• Les méthodes d’access sont: setter et getter.

Exemple: .h

 @interface XYZClass : NSObject @property (nonatomic, retain) NSSsortingng *name; @end 

.m

 @implementation XYZClass @synthesize name; @end 

Maintenant, le compilateur synthétisera les méthodes d’access pour le nom .

 XYZClass *obj=[[XYZClass alloc]init]; NSSsortingng *name1=[obj name]; // get 'name' [obj setName:@"liza"]; // first letter of 'name' becomes capital in setter method 

• Liste des atsortingbuts de @property

  atomique, non atomique, conserver, copier, en lecture seule, réécrire, assigner, fort, getter = méthode, setter = méthode, unsafe_unretained

• atomique est le comportement par défaut. Si un object est déclaré comme atomique, il devient alors thread-safe. Thread-safe signifie qu’à la fois, un seul thread d’une instance particulière de cette classe peut contrôler cet object.

Si le thread exécute la méthode getter, alors un autre thread ne peut pas exécuter la méthode setter sur cet object. C’est lent.

 @property NSSsortingng *name; //by default atomic` @property (atomic)NSSsortingng *name; // explicitly declared atomic` 

• nonatomic n’est pas thread-safe. Vous pouvez utiliser l’atsortingbut de propriété nonatomique pour spécifier que les accesseurs synthétisés définissent ou renvoient une valeur directement, sans aucune garantie quant à ce qui se passe si cette même valeur est accessible simultanément à partir de différents threads.

Pour cette raison, il est plus rapide d’accéder à une propriété non atomique qu’à une propriété atomique.

 @property (nonatomic)NSSsortingng *name; 

• Retenir est requirejs lorsque l’atsortingbut est un pointeur sur un object.

La méthode setter augmentera le compte de conservation de l’object, de sorte qu’il occupera la mémoire dans le pool d’autorelease.

 @property (retain)NSSsortingng *name; 

• copier Si vous utilisez la copie, vous ne pouvez pas utiliser conserver. L’utilisation de l’instance de copie de la classe contiendra sa propre copie.

Même si une chaîne mutable est définie et modifiée par la suite, l’instance capture toute valeur dont elle dispose au moment où elle est définie. Aucune méthode setter et getter ne sera synthétisée.

 @property (copy) NSSsortingng *name; 

à présent,

 NSMutableSsortingng *nameSsortingng = [NSMutableSsortingng ssortingngWithSsortingng:@"Liza"]; xyzObj.name = nameSsortingng; [nameSsortingng appendSsortingng:@"Pizza"]; 

le nom restra inchangé.

• readonly Si vous ne souhaitez pas autoriser la modification de la propriété via la méthode setter, vous pouvez déclarer la propriété readonly.

Le compilateur générera un getter, mais pas un setter.

 @property (readonly) NSSsortingng *name; 

• readwrite est le comportement par défaut. Vous n’avez pas besoin de spécifier explicitement l’atsortingbut readwrite.

C’est l’opposé de readonly.

 @property (readwrite) NSSsortingng *name; 

• assign va générer un setter qui assigne directement la valeur à la variable d’instance, plutôt que de la copier ou de la conserver. Cela convient mieux aux types primitifs comme NSInteger et CGFloat, ou aux objects que vous ne possédez pas directement, tels que les delegates.

Gardez à l’esprit que conserver et affecter sont fondamentalement interchangeables lorsque la récupération de place est activée.

 @property (assign) NSInteger year; 

• fort est un remplacement pour conserver.

Il est livré avec ARC.

 @property (nonatomic, strong) AVPlayer *player; 

• getter = method Si vous souhaitez utiliser un nom différent pour une méthode getter, il est possible de spécifier un nom personnalisé en ajoutant des atsortingbuts à la propriété.

Dans le cas des propriétés booléennes (propriétés qui ont une valeur YES ou NO), il est habituel que la méthode getter commence par le mot «is»

 @property (getter=isFinished) BOOL finished; 

• setter = method Si vous souhaitez utiliser un nom différent pour une méthode setter, il est possible de spécifier un nom personnalisé en ajoutant des atsortingbuts à la propriété.

La méthode doit se terminer par un deux-points.

 @property(setter = boolBool:) BOOL finished; 

• unsafe_unretained Il existe quelques classes dans Cocoa et Cocoa Touch qui ne prennent pas encore en charge les références faibles, ce qui signifie que vous ne pouvez pas déclarer une propriété faible ou une variable locale faible pour les suivre. Ces classes incluent NSTextView, NSFont et NSColorSpace, etc. Si vous devez utiliser une référence faible à l’une de ces classes, vous devez utiliser une référence non sécurisée.

Une référence non sécurisée est similaire à une référence faible dans la mesure où elle ne conserve pas son object associé en vie, mais elle ne sera pas définie sur zéro si l’object de destination est désalloué.

 @property (unsafe_unretained) NSObject *unsafeProperty; 

Si vous devez spécifier plusieurs atsortingbuts, incluez-les simplement comme une liste séparée par des virgules, comme ceci:

 @property (readonly, getter=isFinished) BOOL finished; 

Après avoir lu de nombreux articles, j’ai décidé de rassembler toutes les informations sur les atsortingbuts:

1. atomique // par défaut
2. non atomique
3. fort = conserver // défaut
4. faible = unsafe_unretained
5. conserver
6. assigner // par défaut
7. unsafe_unretained
8. copie
9. lecture seulement
10. readwrite // default

Vous trouverez ci-dessous un lien vers l’article détaillé où vous pouvez trouver ces atsortingbuts.

Un grand merci à toutes les personnes qui donnent les meilleures réponses ici !!

Atsortingbuts de propriété de variable ou modificateurs dans iOS

Voici l’exemple de description de l’article

1. atomique -Atomic signifie qu’un seul thread accède à la variable (type statique). -Atomic est thread-safe. -mais c’est lent dans les performances -atomique est le comportement par défaut -Accessoires Atomic dans un environnement non garbage collecté (c’est-à-dire lors de l’utilisation de Retain / Release / Autorelease) utilisera un verrou pour s’assurer qu’un autre thread n’interfère pas de la valeur. -Il n’est pas réellement un mot clé.

Exemple :

 @property (retain) NSSsortingng *name; @synthesize name; 

2. nonatomique -Nonatomique signifie l’access multiple à la variable (type dynamic). -Nonatomic est le fil dangereux. -mais il est rapide en performance -Nonatomic n’est pas un comportement par défaut, nous devons append un mot-clé nonatomique dans l’atsortingbut de propriété. -Il peut entraîner un comportement inattendu lorsque deux processus (threads) différents accèdent à la même variable en même temps.

Exemple:

 @property (nonatomic, retain) NSSsortingng *name; @synthesize name; 

Explique:

Supposons qu’il existe une propriété de chaîne atomique appelée “name”, et si vous appelez [self setName: @ “A”] à partir du thread A, appelez [self setName: @ “B”] à partir du thread B, et appelez [self name] from thread C, alors toutes les opérations sur des threads différents seront effectuées en série, ce qui signifie que si un thread exécute setter ou getter, alors d’autres threads attendent. Cela rend la propriété “name” en lecture / écriture sûre, mais si un autre thread D appelle [release release] simultanément, cette opération peut provoquer un plantage car aucun appel setter / getter n’est impliqué ici. Ce qui signifie qu’un object est en lecture / écriture sécurisé (ATOMIC) mais pas thread-safe car un autre thread peut envoyer simultanément n’importe quel type de message à l’object. Le développeur doit assurer la sécurité des threads pour ces objects.

Si la propriété “name” était non atomique, alors tous les threads de l’exemple ci-dessus – A, B, C et D s’exécuteront simultanément, produisant un résultat imprévisible. En cas d’atome, Soit l’un des A, B ou C s’exécutera en premier mais D pourra toujours s’exécuter en parallèle.

3. fort (iOS4 = keep) -il dit “gardez ça dans le tas jusqu’à ce que je ne le pointe plus” -en d’autres termes “je suis le propriétaire, vous ne pouvez pas traiter ceci avant de viser bien avec la même chose que conserver” – Vous utilisez fort uniquement si vous devez conserver l’object. -Par défaut, toutes les variables d’instance et les variables locales sont des pointeurs forts. -Nous utilisons généralement fort pour UIViewControllers (les parents des éléments de l’interface utilisateur) – ils sont fortement utilisés avec ARC et cela vous aide fondamentalement, car vous n’avez pas à vous soucier du nombre de rétentions d’un object. ARC vous le libère automatiquement lorsque vous en avez fini. Utiliser le mot-clé fort signifie que vous êtes propriétaire de l’object.

Exemple:

 @property (strong, nonatomic) ViewController *viewController; @synthesize viewController; 

4. faible (iOS4 = unsafe_unretained) -Il dit “conservez ceci tant que quelqu’un d’autre le pointe fortement” -la même chose que assigner, pas de conserver ou de libérer -Une référence “faible” est une référence que vous ne conservez pas. -Nous utilisons généralement faible pour IBOutlets (Childs de UIViewController). Cela fonctionne parce que l’object enfant doit seulement exister aussi longtemps que l’object parent. -une référence faible est une référence qui ne protège pas l’object référencé de la collecte par un ramasse-miettes. -Weak est essentiellement assigner, une propriété non retenue. Sauf que lorsque l’object est désalloué, le pointeur faible est automatiquement mis à zéro

Exemple :

 @property (weak, nonatomic) IBOutlet UIButton *myButton; @synthesize myButton; 

Explication forte et faible, merci à BJ Homer :

Imaginez que notre object soit un chien et que le chien veuille s’enfuir (soit désalloué). Les pointeurs forts sont comme une laisse sur le chien. Tant que vous avez la laisse attachée au chien, le chien ne va pas fuir. Si cinq personnes attachent leur laisse à un chien (cinq pointeurs forts sur un object), le chien ne s’enfuira pas avant que les cinq laisses ne soient détachées. Les pointeurs faibles, d’autre part, sont comme des petits enfants qui pointent vers le chien et disent: “Regardez! Un chien!” Tant que le chien est toujours en laisse, les petits peuvent encore voir le chien, et ils le montreront toujours. Dès que toutes les laisses sont détachées, le chien s’enfuit peu importe le nombre de petits enfants qui le pointent. Dès que le dernier pointeur fort (leash) ne pointe plus vers un object, l’object sera libéré et tous les pointeurs faibles seront mis à zéro. Quand on utilise faible? Le seul moment où vous voudriez utiliser des faiblesses, c’est si vous vouliez éviter les cycles de rétention (par exemple, le parent conserve l’enfant et l’enfant conserve le parent, donc aucun n’est libéré).

5. keep = strong -it est conservé, l’ancienne valeur est libérée et -retain lui est atsortingbué. La nouvelle valeur doit être envoyée -retain lors de l’affectation et l’ancienne valeur envoyée -release -retain est la même que strong. -apple dit que si vous écrivez retenez, cela convertira automatiquement / travaillera comme fort seulement. -Les méthodes telles que “alloc” incluent un “conserve” implicite

Exemple:

 @property (nonatomic, retain) NSSsortingng *name; @synthesize name; 

6. assign -assign est la valeur par défaut et effectue simplement une affectation de variable -assign est un atsortingbut de propriété qui indique au compilateur comment synthétiser l’implémentation setter de la propriété.

Exemple:

 @property (nonatomic, assign) NSSsortingng *address; @synthesize address; 

7. unsafe_unretained

   -unsafe_unretained est un qualificatif de propriété qui indique à ARC comment insérer des appels de conservation / de libération -unsafe_unretained est la version ARC de assign.

Exemple:

 @property (nonatomic, unsafe_unretained) NSSsortingng *nickName; @synthesize nickName; 

8. copy -copy est requirejs lorsque l’object est modifiable. -copy spécifie que la nouvelle valeur doit être envoyée -copy lors de l’affectation et l’ancienne valeur envoyée -release. -copy est comme retenir renvoie un object que vous devez explicitement libérer (par exemple, dans dealloc) dans des environnements non collectés. -si vous utilisez copy, vous devez toujours le publier dans dealloc. -Utilisez cela si vous avez besoin de la valeur de l’object tel qu’il est actuellement et que vous ne voulez pas que cette valeur reflète les modifications apscopes par d’autres propriétaires de l’object. Vous devrez libérer l’object lorsque vous en aurez fini car vous en conservez la copie.

Exemple:

 @property (nonatomic, copy) NSArray *myArray; @synthesize myArray; 

La propriété atomique est accessible par un seul thread à la fois. C’est thread-safe . La valeur par défaut est atomique. Veuillez noter qu’il n’y a pas de mot clé atomique

Nonatomique signifie que plusieurs threads peuvent accéder à l’élément.

Donc, il faut être très prudent lors de l’utilisation de l’atome. Comme cela affecte les performances de votre code