se capturer fortement dans ce bloc est susceptible d'entraîner un cycle de rétention

Comment puis-je éviter cet avertissement dans xcode. Voici l'extrait de code:

[player(AVPlayer object) addPeriodicTimeObserverForInterval:CMTimeMakeWithSeconds(0.1, 100)
queue:nil usingBlock:^(CMTime time) {
    current+=1;

    if(current==60)
    {
        min+=(current/60);
        current = 0;
    }

    [timerDisp(UILabel) setText:[NSString stringWithFormat:@"%02d:%02d",min,current]];///warning occurs in this line
}];

La capture d' selfici arrive avec votre accès implicite à la propriété de self.timerDisp- vous ne pouvez pas faire référence à selfou à des propriétés selfdans un bloc qui sera fortement conservé par self.

Vous pouvez contourner cela en créant une référence faible selfavant d'accéder à l' timerDispintérieur de votre bloc:

__weak typeof(self) weakSelf = self;
[player addPeriodicTimeObserverForInterval:CMTimeMakeWithSeconds(0.1, 100)
                                     queue:nil
                                usingBlock:^(CMTime time) {
                                                current+=1;

                                                if(current==60)
                                                {
                                                    min+=(current/60);
                                                    current = 0;
                                                }

                                                 [weakSelf.timerDisp setText:[NSString stringWithFormat:@"%02d:%02d",min,current]];
                                            }];

__weak MyClass *self_ = self; // that's enough
self.loadingDidFinishHandler = ^(NSArray *receivedItems, NSError *error){
    if (!error) {
       [self_ showAlertWithError:error];
    } else {
       self_.items = [NSArray arrayWithArray:receivedItems];
       [self_.tableView reloadData];
    }
};

Et une chose très importante à retenir: n'utilisez pas de variables d'instance directement dans le bloc, utilisez-les comme propriétés d'un objet faible, échantillon:

self.loadingDidFinishHandler = ^(NSArray *receivedItems, NSError *error){
        if (!error) {
           [self_ showAlertWithError:error];
        } else {
           self_.items = [NSArray arrayWithArray:receivedItems];
           [_tableView reloadData]; // BAD! IT ALSO WILL BRING YOU TO RETAIN LOOP
        }
 };

et n'oubliez pas de faire:

- (void)dealloc {
    self.loadingCompletionHandler = NULL;
}

un autre problème peut apparaître si vous passez une copie faible de l'objet non conservé par quelqu'un:

MyViewController *vcToGo = [[MyViewCOntroller alloc] init];
__weak MyViewController *vcToGo_ = vcToGo;
self.loadingCompletion = ^{
    [vcToGo_ doSomePrecessing];
};

Si vcToGosera désalloué et que ce bloc sera déclenché, je pense que vous obtiendrez un crash avec un sélecteur non reconnu dans une corbeille qui contient vcToGo_maintenant une variable. Essayez de le contrôler.

Meilleure version

__strong typeof(self) strongSelf = weakSelf;

Créez une référence forte à cette version faible comme première ligne de votre bloc. Si self existe toujours lorsque le bloc commence à s'exécuter et n'est pas revenu à zéro, cette ligne garantit qu'il persiste pendant toute la durée d'exécution du bloc.

Donc, le tout serait comme ça:

// Establish the weak self reference
__weak typeof(self) weakSelf = self;

[player addPeriodicTimeObserverForInterval:CMTimeMakeWithSeconds(0.1, 100)
                                 queue:nil
                            usingBlock:^(CMTime time) {

    // Establish the strong self reference
    __strong typeof(self) strongSelf = weakSelf;

    if (strongSelf) {
        [strongSelf.timerDisp setText:[NSString stringWithFormat:@"%02d:%02d",min,current]];
    } else {
        // self doesn't exist
    }
}];

J'ai lu cet article plusieurs fois. Ceci est un excellent article par Erica Sadun sur la façon d'éviter les problèmes lors de l'utilisation de blocs et de NSNotificationCenter

Mise à jour rapide:

Par exemple, dans swift, une méthode simple avec bloc de réussite serait:

func doSomeThingWithSuccessBlock(success: () -> ()) {
    success()
}

Lorsque nous appelons cette méthode et devons l'utiliser selfdans le bloc de réussite. Nous utiliserons les fonctionnalités [weak self]et guard let.

    doSomeThingWithSuccessBlock { [weak self] () -> () in
        guard let strongSelf = self else { return }
        strongSelf.gridCollectionView.reloadData()
    }

Cette danse dite forte-faible est utilisée par des projets open source populaires Alamofire.

Pour plus d'informations, consultez le guide de style rapide

Dans une autre réponse, Tim a déclaré:

vous ne pouvez pas faire référence à soi ou à des propriétés sur soi à partir d'un bloc qui sera fortement conservé par lui-même.

Ce n'est pas tout à fait vrai. Vous pouvez le faire tant que vous rompez le cycle à un moment donné. Par exemple, disons que vous avez une minuterie qui se déclenche qui a un bloc qui se conserve et que vous gardez également une référence forte à la minuterie en soi. C'est parfaitement bien si vous savez toujours que vous allez détruire la minuterie à un moment donné et briser le cycle.

Dans mon cas tout à l'heure, j'ai eu cet avertissement pour le code qui:

[x setY:^{ [x doSomething]; }];

Maintenant, je sais que clang ne produira cet avertissement que s'il détecte que la méthode commence par «set» (et un autre cas spécial que je ne mentionnerai pas ici). Pour moi, je sais qu'il n'y a aucun danger qu'il y ait une boucle de retenue, j'ai donc changé le nom de la méthode en «useY:» Bien sûr, cela pourrait ne pas être approprié dans tous les cas et généralement vous voudrez utiliser une référence faible, mais J'ai pensé qu'il valait la peine de noter ma solution au cas où cela aiderait les autres.

Plusieurs fois, ce n'est pas réellement un cycle de conservation .

Si vous savez que ce n'est pas le cas, vous n'avez pas besoin de mettre au monde des faibles faibles.

Apple nous impose même ces avertissements avec l'API UIPageViewController, ce qui inclut une méthode définie (qui déclenche ces avertissements - comme mentionné ailleurs - en pensant que vous définissez une valeur pour un ivar qui est un bloc) et un bloc de gestionnaire d'achèvement (dans lequel vous vous référerez sans aucun doute à vous-même).

Voici quelques directives du compilateur pour supprimer l'avertissement de cette seule ligne de code:

#pragma GCC diagnostic push
#pragma clang diagnostic ignored "-Warc-retain-cycles"
    [self.pageViewController setViewControllers:@[newViewController] direction:navigationDirection animated:YES completion:^(BOOL finished) {
        // this warning is caused because "setViewControllers" starts with "set…", it's not a problem
        [self doTheThingsIGottaDo:finished touchThePuppetHead:YES];
    }];
#pragma GCC diagnostic pop

Ajout de deux cents sur l'amélioration de la précision et du style. Dans la plupart des cas, vous n'utiliserez qu'un ou deux membres de selfdans ce bloc, très probablement juste pour mettre à jour un curseur. Le casting selfest exagéré. Au lieu de cela, il vaut mieux être explicite et ne diffuser que les objets dont vous avez vraiment besoin à l'intérieur du bloc. Par exemple, si c'est une instance de UISlider*, disons, _timeSliderfaites simplement ce qui suit avant la déclaration de bloc:

UISlider* __weak slider = _timeSlider;

Ensuite, utilisez simplement l' sliderintérieur du bloc. Techniquement, cela est plus précis car il réduit le cycle de rétention potentiel à l'objet dont vous avez besoin, pas à tous les objets à l'intérieur self.

Exemple complet:

UISlider* __weak slider = _timeSlider;
[_embeddedPlayer addPeriodicTimeObserverForInterval:CMTimeMake(1, 1)
     queue:nil
     usingBlock:^(CMTime time){
        slider.value = time.value/time.timescale;
     }
];

De plus, très probablement, l'objet projeté sur un pointeur faible est déjà un pointeur faible à l'intérieur, ce selfqui minimise ou élimine complètement la probabilité d'un cycle de rétention. Dans l'exemple ci-dessus, _timeSliderest en fait une propriété stockée en tant que référence faible, par exemple:

@property (nonatomic, weak) IBOutlet UISlider* timeSlider;

En termes de style de codage, comme avec C et C ++, les déclarations de variables sont mieux lues de droite à gauche. Déclarant SomeType* __weak variabledans cet ordre se lit plus naturellement de droite à gauche comme: variable is a weak pointer to SomeType.

J'ai rencontré cet avertissement récemment et je voulais mieux le comprendre. Après un peu d'essais et d'erreurs, j'ai découvert qu'elle provenait du fait qu'une méthode commence par "ajouter" ou "enregistrer". Objective C traite les noms de méthode commençant par "new", "alloc", etc. comme renvoyant un objet conservé mais ne mentionne (que je peux trouver) rien concernant "add" ou "save". Cependant, si j'utilise un nom de méthode de cette manière:

[self addItemWithCompletionBlock:^(NSError *error) {
            [self done]; }];

Je verrai l'avertissement sur la ligne [self done]. Cependant, cela ne:

[self itemWithCompletionBlock:^(NSError *error) {
    [self done]; }];

Je vais aller de l'avant et utiliser la méthode "__weak __typeof (self) faiblesseSelf = self" pour référencer mon objet mais n'aime vraiment pas avoir à le faire car cela confondra un futur moi et / ou un autre développeur. Bien sûr, je ne pouvais pas non plus utiliser "ajouter" (ou "enregistrer") mais c'est pire car cela enlève le sens de la méthode.