Toujours passer une référence faible de soi en bloc dans ARC?

Je suis un peu confus quant à l'utilisation des blocs dans Objective-C. J'utilise actuellement ARC et j'ai beaucoup de blocs dans mon application, faisant toujours référence à la selfplace de sa référence faible. Cela peut-il être la raison pour laquelle ces blocs le retiennent selfet l'empêchent d'être désalloué? La question est, dois-je toujours utiliser une weakréférence de selfdans un bloc?

-(void)handleNewerData:(NSArray *)arr
{
    ProcessOperation *operation =
    [[ProcessOperation alloc] initWithDataToProcess:arr
                                         completion:^(NSMutableArray *rows) {
        dispatch_async(dispatch_get_main_queue(), ^{
            [self updateFeed:arr rows:rows];
        });
    }];
    [dataProcessQueue addOperation:operation];
}

ProcessOperation.h

@interface ProcessOperation : NSOperation
{
    NSMutableArray *dataArr;
    NSMutableArray *rowHeightsArr;
    void (^callback)(NSMutableArray *rows);
}

ProcessOperation.m

-(id)initWithDataToProcess:(NSArray *)data completion:(void (^)(NSMutableArray *rows))cb{

    if(self =[super init]){
        dataArr = [NSMutableArray arrayWithArray:data];
        rowHeightsArr = [NSMutableArray new];
        callback = cb;
    }
    return self;
}

- (void)main {
    @autoreleasepool {
        ...
        callback(rowHeightsArr);
    }
}

Cela aide à ne pas se concentrer sur la partie strongou la weakpartie de la discussion. Concentrez-vous plutôt sur la partie cycle .

Un cycle de rétention est une boucle qui se produit lorsque l’objet A conserve l’objet B et que l’ objet B conserve l’objet A. Dans ce cas, si l’un ou l’autre des objets est libéré:

• L'objet A ne sera pas désalloué car l'objet B en contient une référence.
• Mais l'objet B ne sera jamais désalloué tant que l'objet A y aura une référence.
• Mais l'objet A ne sera jamais désalloué car l'objet B en contient une référence.
• À l'infini

Ainsi, ces deux objets resteront simplement en mémoire pendant toute la durée de vie du programme, même s'ils doivent, si tout fonctionnait correctement, être désalloués.

Donc, ce qui nous inquiète, c'est de conserver les cycles , et il n'y a rien sur les blocs en soi qui créent ces cycles. Ce n'est pas un problème, par exemple:

[myArray enumerateObjectsUsingBlock:^(id obj, NSUInteger idx, BOOL *stop){
   [self doSomethingWithObject:obj];
}];

Le bloc conserve self, mais selfne conserve pas le bloc. Si l'un ou l'autre est libéré, aucun cycle n'est créé et tout est désalloué comme il se doit.

Là où vous avez des ennuis, c'est quelque chose comme:

//In the interface:
@property (strong) void(^myBlock)(id obj, NSUInteger idx, BOOL *stop);

//In the implementation:
[self setMyBlock:^(id obj, NSUInteger idx, BOOL *stop) {
  [self doSomethingWithObj:obj];     
}];

Maintenant, votre objet ( self) a une strongréférence explicite au bloc. Et le bloc a une référence forte implicite à self. C'est un cycle, et maintenant aucun objet ne sera désalloué correctement.

Parce que, dans une situation comme celle-ci, self par définition a déjà une strongréférence au bloc, il est généralement plus facile à résoudre en faisant une référence explicitement faible au selfbloc à utiliser:

__weak MyObject *weakSelf = self;
[self setMyBlock:^(id obj, NSUInteger idx, BOOL *stop) {
  [weakSelf doSomethingWithObj:obj];     
}];

Mais cela ne devrait pas être le modèle par défaut que vous suivez lorsque vous traitez avec des blocs qui appellent self! Cela ne doit être utilisé que pour rompre ce qui serait autrement un cycle de rétention entre soi et le bloc. Si vous deviez adopter ce modèle partout, vous courriez le risque de passer un bloc à quelque chose qui a été exécuté après avoir selfété désalloué.

//SUSPICIOUS EXAMPLE:
__weak MyObject *weakSelf = self;
[[SomeOtherObject alloc] initWithCompletion:^{
  //By the time this gets called, "weakSelf" might be nil because it's not retained!
  [weakSelf doSomething];
}];

Vous n'êtes pas obligé de toujours utiliser une référence faible. Si votre bloc n'est pas conservé, mais exécuté puis rejeté, vous pouvez vous capturer fortement, car cela ne créera pas de cycle de conservation. Dans certains cas, vous souhaitez même que le bloc se maintienne jusqu'à la fin du bloc afin qu'il ne se désalloue pas prématurément. Cependant, si vous capturez fortement le bloc et que vous vous capturez à l'intérieur, cela créera un cycle de rétention.

Je suis totalement d'accord avec @jemmons:

Mais cela ne devrait pas être le modèle par défaut que vous suivez lorsque vous traitez avec des blocs qui s'appellent eux-mêmes! Cela ne doit être utilisé que pour rompre ce qui serait autrement un cycle de rétention entre soi et le bloc. Si vous deviez adopter ce modèle partout, vous courriez le risque de passer un bloc à quelque chose qui a été exécuté après que self ait été désalloué.

//SUSPICIOUS EXAMPLE:
__weak MyObject *weakSelf = self;
[[SomeOtherObject alloc] initWithCompletion:^{
  //By the time this gets called, "weakSelf" might be nil because it's not  retained!
  [weakSelf doSomething];
}];

Pour surmonter ce problème, on peut définir une référence forte sur l' weakSelfintérieur du bloc:

__weak MyObject *weakSelf = self;
[[SomeOtherObject alloc] initWithCompletion:^{
  MyObject *strongSelf = weakSelf;
  [strongSelf doSomething];
}];

Comme Leo le fait remarquer, le code que vous avez ajouté à votre question ne suggère pas un cycle de référence solide (aka, cycle de conservation). Un problème lié à l'opération qui pourrait provoquer un cycle de référence fort serait si l'opération n'est pas libérée. Bien que votre extrait de code suggère que vous n'avez pas défini votre opération comme étant simultanée, mais si vous l'avez, elle ne sera pas publiée si vous n'avez jamais publié isFinished, ou si vous aviez des dépendances circulaires, ou quelque chose comme ça. Et si l'opération n'est pas validée, le contrôleur de vue ne le sera pas non plus. Je suggère d'ajouter un point d'arrêt ou NSLogdans la deallocméthode de votre opération et de confirmer que cela est appelé.

Tu as dit:

Je comprends la notion de cycles de rétention, mais je ne sais pas trop ce qui se passe dans les blocs, ce qui m'embrouille un peu

Les problèmes de cycle de rétention (cycle de référence fort) qui se produisent avec les blocs sont similaires aux problèmes de cycle de rétention que vous connaissez. Un bloc conservera des références fortes à tous les objets qui apparaissent dans le bloc, et il ne libérera pas ces références fortes jusqu'à ce que le bloc lui-même soit libéré. Ainsi, si le bloc fait référence self, ou même fait simplement référence à une variable d'instance de self, qui maintiendra une référence forte à soi, cela n'est pas résolu jusqu'à ce que le bloc soit libéré (ou dans ce cas, jusqu'à ce que la NSOperationsous-classe soit libérée.

Pour plus d'informations, consultez la section Évitez les cycles de référence forts lors de la capture de l'auto- section du document Programmation avec Objective-C: Travailler avec des blocs .

Si votre contrôleur de vue n'est toujours pas libéré, il vous suffit d'identifier où réside la référence forte non résolue (en supposant que vous avez confirmé que la NSOperationdésallocation est en cours). Un exemple courant est l'utilisation d'une répétition NSTimer. Ou un delegateobjet personnalisé ou autre qui maintient par erreur une strongréférence. Vous pouvez souvent utiliser des instruments pour localiser où les objets obtiennent leurs références fortes, par exemple:

Ou dans Xcode 5:

Quelques explications ignorer une condition sur le cycle de conserver [Si un groupe d'objets est relié par un cercle de relations solides, ils se tiennent mutuellement en vie , même s'il n'y a pas de solides références à l' extérieur du groupe.] Pour plus d' informations, lire le document de

Voici comment vous pouvez utiliser le self à l'intérieur du bloc:

// appel du bloc

 NSString *returnedText= checkIfOutsideMethodIsCalled(self);

NSString* (^checkIfOutsideMethodIsCalled)(*)=^NSString*(id obj)
{
             [obj MethodNameYouWantToCall]; // this is how it will call the object 
            return @"Called";


};