Block doesn't capture self - ios

Question

I want try to understand block capture logic and now I have question about it. I have MeRequest and NSNumber properties.
#property (nonatomic) MeRequest *request;
#property (nonatomic) NSNumber *number;
Then, in viewDidLoad i call request method
self.request = [[MeRequest alloc] init];
[self.request meInfoSuccessBlock:^(NSDictionary *response) {
} failureBlock:^(Error *error) {
self.number = #5;
}];
- (void)meInfoSuccessBlock:(RequestSuccessBlock)success failureBlock:(RequestFailureBlock)failure {
self.method = #"GET";
self.parameters = #{};
[self performWithCompletion:^(id responseObject) {
NSDictionary *response = (NSDictionary *)responseObject;
if (success) {
success(response);
}
} onFailure:^(Error *error) {
if (failure) {
failure(error);
}
}];
}
- (AFHTTPRequestOperation *)performWithCompletion:(void(^)(id responseObject))completion
onFailure:(void(^)(Error *error))failure {
NSURLRequest *request = [[NetworkManager sharedManager] requestWithMethod:self.method path:self.path parameters:self.parameters];
if (_operation) {
[_operation cancel];
}
_operation = [[NetworkManager sharedManager] HTTPRequestOperationWithRequest:request success:^(AFHTTPRequestOperation *operation, id responseObject) {
_operation = nil;
dispatch_semaphore_signal(_semaphore);
if (completion) {
completion(responseObject);
}
} failure:^(AFHTTPRequestOperation *operation, NSError *error) {
_operation = nil;
dispatch_semaphore_signal(_semaphore);
if (failure) {
failure(_error);
}
}];
[_operation start];
return _operation;
}
And in failureBlock I set number to property. When I leave this controller I see dealloc message in console, that controller has been dealloced.
- (void)dealloc {
NSLog(#"%s", __PRETTY_FUNCTION__);
}
Why controller deallocs? I don't use weak reference to self

Answer 1

To know definitively, you'd have to post the implementation of the MeRequest class.
Without knowing that, this is an educated guess.
The blocks passed into self.request via meInfoSuccessBlock:failureBlock: may be nil'd out when the transaction is complete. That is, it may be something like:
- (void)meInfoSuccessBlock:... sB failureBlock:... fB {
_sB = sB; // put ref in ivar
_fB = fB; // because this is probably broken up across methods
dispatch_async(_queue, ^{
.... think hard ...
if (success) _sB(...);
else _fB(...);
_sB = nil;
_fB = nil;
};
}
So, first, you aren't creating a direct cyclic reference, but -- maybe -- a cyclic reference of self -> request -> _sB -> self. And, secondly, by assigning _sB = nil after computation is done and the callback is made, the cycle is broken.
Or, in your case, you have strong references to the blocks that only survive the scope. I.e. kinda like this:
- (void)meInfoSuccessBlock:... sB failureBlock:... fB {
dispatch_async(_queue, ^{
.... think hard ...
if (success) sB(...);
else fB(...);
// when the block finishes execution, fB and sB will be released
};
// when execution gets to here, the block above is the only strong references to sB and fB
}
That is, while you have a retain cycle, one reference in that cycle is explicitly tied to the lifespan of the callback blocks and since those only survive until the callback is complete, they get destroyed and that destroys the cycle.