Lifetime of a class and blocks - objective-c

Question

When a class created by a UIViewController serves as completion block to another class, how does the memory management lifecycle work when UIViewController gets a dealloc call?
Let's say UIViewController inheriting class instantiates a class, ControllerMediatorClass.
ControllerMediatorClass in turn invokes another class, ClassThatDealsWithNetworking, whose work takes some time to complete.
If the UIViewController gets its dealloc before the ClassThatDealsWithNetworking finishes up, when would the classes under its ownership get cleaned up?
Would the instance of 'ControllerMediatorClass' not get deallocated immediately when MyUIViewController sets it to nil because ControllerMediatorClass still serves as a completion block to the instance of ClassThatDealsWithNetworking?
MyUIViewController:
#property (nonatomic, strong) ControllerMediatorClass *mediatorClass;
- (IBAction)userTappedSomething
{
[mediatorClass makeANetworkCall];
}
- (void)dealloc
{
self.mediatorClass = nil;
}
ControllerMediatorClass:
- (void)makeANetworkCall
{
ClassThatDealsWithNetworking *networkCommand;
[networkCommand execute:^(NSDictionary *data)
{
// handling completion that
} error:^(MyError *error)
{
// handling completion
}
];
}
(using ARC)

Answer 1

Would the instance of 'ControllerMediatorClass' not get deallocated immediately when MyUIViewController sets it to nil because ControllerMediatorClass still serves as a completion block to the instance of ClassThatDealsWithNetworking?
Yes. Because blocks automatically capture objects that it uses and retain them as long as the block is retained.
So, as the [ClassThatDealsWithNetworking execute:] method will probably retain the completion block that is passed to it, then execute the network call in the background, then call the block once done and release the block, when the block is retained every variable that is used in this block is retained too. And will be released when the block is released.
So imagine this pseudo-code for your ClassThatDealsWithNetworking class:
typedef void(^NetworkingCompletionBlock)(NSDictionary* data)
#interface ClassThatDealsWithNetworking
#property(nonatomic, copy) NetworkingCompletionBlock completionBlock;
-(void)execute:(NetworkingCompletionBlock)block;
#end
#implementation ClassThatDealsWithNetworking
-(void)execute:(NetworkingCompletionBlock)block {
// make a copy of the block passed as a parameter
// so that we keep the completionBlock around inside
// the ClassThatDealsWithNetworking instance
// until the network request has finished
// ==> THIS WILL implicitly RETAIN every object used in the completionBlock
self.completionBlock = block;
...
// Then perform the network request
[NSURLConnection connectionWithRequest:... delegate:self];
...
}
-(void)connection:(NSURLConnection*)cxn didFailWithError:(NSError*)error
{
// call the completion block here
self.completionBlock(nil,error);
// then release the completionBlock
// ==> THIS WILL RELEASE every object previously implicitly retained by the completionBlock
self.completionBlock = nil;
}
-(void)connectionDidFinishLoading:(NSURLConnection*)cxn
{
NSDictionary* data = ...
// call the completion block here
self.completionBlock(data,nil);
// then release the completionBlock
// ==> THIS WILL RELEASE every object previously implicitly retained by the completionBlock
self.completionBlock = nil;
}
#end
Then if you do this:
[networkCommand execute:^(NSDictionary *data)
{
self.someProperty = data;
} error:^(MyError *error)
{
NSLog(#"%#", error);
self.someProperty : nil;
}];
Then self (your ControllerMediatorClass in your example) WILL BE implicitly RETAINED by the block itself, as long as the block exists, because your reference self in the body of the block somewhere. So the compiler knows that it will need it when the block is executed and retain it. And it will be implicitly released when the block is released.
This ensures that all the objects you use in the body of your block will still exist when the block is executed, avoiding to crash.
Note that this may lead to retain cycle if you are not careful. For example, if you forget to self self.completionBlock = nil in the ClassThatDealsWithNetworking class (in the delegate methods or in the dealloc method), the block will never be released by the ClassThatDealsWithNetworking instance, and will keep retaining self.
For more information, read the Blocks Programming Guide in the Apple documentation.