Kendini zayıf referansını her zaman ARC'de bloğa mı geçireceksin?

Objective-C'de blok kullanımı konusunda biraz kafam karıştı. Şu anda ARC kullanıyorum ve uygulamamda çok fazla blok var, şu anda selfzayıf referansı yerine her zaman atıfta bulunuyor . Bu blokların selftutulup tutulmalarının nedeni bu olabilir mi? Soru, bir blokta her zaman bir weakreferans kullanmalı selfmıyım?

-(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);
    }
}

Tartışmaya strongveya weaktartışmaya odaklanmamaya yardımcı olur . Bunun yerine döngü kısmına odaklanın .

Bir tutma döngüsü , A Nesnesi B Nesnesi'ni tuttuğunda ve B Nesnesi A Nesnesi'ni koruduğunda gerçekleşen bir döngüdür . Bu durumda, iki nesneden biri serbest bırakılırsa:

• A Nesnesi yeniden konumlandırılmaz çünkü B Nesnesi buna bir referans tutar.
• Ancak A nesnesinin bir referansı olduğu sürece B Nesnesi hiçbir zaman yeniden konumlandırılmaz.
• Ancak A Nesnesi hiçbir zaman yeniden konumlandırılmaz çünkü B Nesnesi buna bir referans tutar.
• sonsuza dek

Bu nedenle, bu iki nesne, programın ömrü boyunca, her şey düzgün çalışıyorsa, yeniden konumlandırılsa bile, bellekte takılır.

Yani, endişelendiğimiz şey döngüleri korumaktır ve kendi içinde ve bu döngüleri oluşturan bloklar hakkında hiçbir şey yoktur. Bu bir sorun değil, örneğin:

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

Blok korur self, ancak bloğu selftutmaz. Biri veya diğeri serbest bırakılırsa, hiçbir döngü oluşturulmaz ve her şey gerektiği gibi yeniden yerleştirilir.

Başın belaya girdiği yer şudur:

//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];     
}];

Şimdi, object ( self) öğeniz strongbloğa açıkça başvuruyor. Ve bloğun örtük güçlü bir referansı var self. Bu bir döngü ve şimdi her iki nesne de doğru şekilde yerleştirilmeyecek.

Bunun gibi bir durumda, self tanım gereği zaten strongbloğa bir referansı olduğu selfiçin, bloğun kullanması için açıkça zayıf bir referans yaparak çözülmesi genellikle en kolay olanıdır :

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

Ancak bu , çağıran bloklarla uğraşırken izlediğiniz varsayılan desen olmamalıdırself ! Bu yalnızca, benlik ve blok arasında bir tutma döngüsünün kırılması için kullanılmalıdır. Bu modeli her yerde benimseyecek olsaydınız, yeniden yerleştirildikten sonra yürütülen bir şeye bir blok geçirme riskiyle karşı karşıya kalırdınız self.

//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];
}];

Her zaman zayıf bir referans kullanmanız gerekmez. Bloğunuz korunmaz, ancak yürütülür ve sonra atılırsa, bir tutma döngüsü oluşturmayacağı için kendini güçlü bir şekilde yakalayabilirsiniz. Bazı durumlarda, bloğun tamamlanıncaya kadar bloğun kendiliğinden kalmasını istersiniz, böylece erken yerleşmez. Bununla birlikte, bloğu güçlü bir şekilde yakalarsanız ve yakalama kendi içinde, bir tutma döngüsü oluşturur.

@Jemmons ile tamamen katılıyorum:

Ancak bu, kendini çağıran bloklarla uğraşırken izlediğiniz varsayılan desen olmamalıdır! Bu yalnızca, benlik ve blok arasında bir tutma döngüsünün kırılması için kullanılmalıdır. Bu modeli her yerde benimseyecek olsaydın, benlik yere yerleştikten sonra yürütülen bir şeye bir blok geçirme riskiyle karşı karşıya kalırdın.

//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];
}];

Bu sorunun üstesinden gelmek için weakSelf, bloğun içinde güçlü bir referans tanımlanabilir :

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

Leo'nun işaret ettiği gibi, sorunuza eklediğiniz kod güçlü bir referans döngüsü (diğer bir deyişle, tutma döngüsü) önermez. Güçlü bir referans döngüsüne neden olabilecek operasyonla ilgili bir sorun, operasyonun serbest bırakılmaması olabilir. Kod snippet'iniz, işleminizi eşzamanlı olarak tanımlamamanızı önermekle birlikte, daha önce hiç göndermediyseniz isFinishedveya dairesel bağımlılıklarınız varsa veya böyle bir şey olsaydı serbest bırakılmaz . İşlem serbest bırakılmazsa, görünüm denetleyicisi de serbest bırakılmaz. Bir kesme noktası veya NSLogişleminizin deallocyöntemine eklemenizi ve bunun çağrıldığını onaylamanızı öneririm .

Dedin:

Tutma döngüleri kavramını anlıyorum, ancak bloklarda ne olacağından emin değilim, bu yüzden beni biraz karıştırıyor

Bloklarla oluşan tutma döngüsü (güçlü referans döngüsü) sorunları, bildiğiniz saklama döngüsü sorunları gibidir. Bir blok, blok içinde görünen herhangi bir nesneye güçlü referanslar sağlar ve blok serbest bırakılıncaya kadar bu güçlü referansları serbest bırakmaz. Bu nedenle, blok referansları self, hatta sadece selfkendine güçlü bir referansı koruyacak bir örnek değişkenini referans alırsa , blok serbest bırakılana kadar (veya bu durumda NSOperationalt sınıf serbest bırakılana kadar) çözülmez .

Daha fazla bilgi için, Objective-C: Bloklarla Çalışma belgesinin Kendini Yakalarken Güçlü Referans Döngülerinden Kaçının bölümüne bakın .

Görünüm denetleyiciniz hala serbest bırakılmıyorsa, çözülmemiş güçlü referansın nerede olduğunu tanımlamanız gerekir (bunun konumlandırıldığını doğruladığınızı varsayarak NSOperation). Yaygın bir örnek, tekrarın kullanılmasıdır NSTimer. Ya delegateda hatalı bir şekilde strongreferansı koruyan bazı özel veya başka bir nesne . Enstrümanları, nesnelerin güçlü referanslarını nereden aldıklarını izlemek için sık sık kullanabilirsiniz, örneğin:

Veya Xcode 5'te:

Bazı açıklamalar tutma döngüsü ile ilgili bir koşulu yok sayar [Bir grup nesne güçlü ilişkiler çemberi ile bağlıysa, grubun dışından güçlü referanslar olmasa bile birbirlerini canlı tutarlar.] Daha fazla bilgi için belgeyi okuyun

Bloğun içindeki benliği şu şekilde kullanabilirsiniz:

// bloğun çağrısı

 NSString *returnedText= checkIfOutsideMethodIsCalled(self);

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


};