__weak general variables declaration for blocks - ios

Question

I am currently working on an implementation where many blocks are used. Every block needs to communicate with self.
Currently I am doing this:
#implementation Foo
- (void) bar
{
__weak Foo *weakSelf = self;
[self doBlockStuff:^(id something) {
[weakSelf doSomething];
}];
}
#end
I have many functions that do the same with the weak instantiation.
Is it right to instantiate the weak property once in the interface block and use it everywhere?
It's working but is it an accepted practice?
#interface Foo ()
{
__weak Foo *_weakSelf;
}
#end
#implementation Foo
-(instancetype) init
{
self = [super init];
if(self) {
_weakSelf = self;
}
return self;
}
- (void) bar1
{
[self doBlockStuff:^(id something) {
[_weakSelf doSomething];
}];
}
- (void) bar2
{
[self doBlockStuff:^(id something) {
[_weakSelf doSomething];
}];
}
- (void) bar3
{
[self doBlockStuff:^(id something) {
[_weakSelf doSomething];
}];
}
- (void) bar4
{
[self doBlockStuff:^(id something) {
[_weakSelf doSomething];
}];
}
#end
Edit after Testing with new Informations:
I did wrote a little test case and now i can demonstrate why the second one is not working.
In my Testclass a imake a dispatch after 5 seconds with the relevant self usage and i logged when my dealloc was called.
#implementation Foo
- (void)dealloc
{
NSLog(#"dealloc");
}
- (instancetype)init
{
self = [super init];
if (self) {
}
return;
}
- (void)bar
{
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(5 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
[self doSomething];
});
}
#end
If the class loses the holder, because the controller is closed or whatever and the function is still running, the class will dialoged after the dispatch is done.
#interface Foo ()
{
__weak Foo *_weakSelf;
}
#end
#implementation Foo
- (void)dealloc
{
NSLog(#"dealloc");
}
- (instancetype)init
{
self = [super init];
if (self) {
_weakSelf = self;
}
return;
}
- (void)bar
{
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(5 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
[_weakSelf doSomething];
});
}
#end
This one will also on dealloc if the dispatch is done. Because the _weakSelf property is still holing by the class, a shorthand for using self->_weak. Self means self :)
#implementation Foo
- (void)dealloc
{
NSLog(#"dealloc");
}
- (instancetype)init
{
self = [super init];
if (self) {
}
return;
}
- (void)bar
{
__weak typeof(self) weakSelf = self;
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(5 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
[weakSelf doSomething];
});
}
#end
this one will dealloc immediately because the weak reference is only existing in this function given to the block. The function is over and if the class loses his reference the block has no property that is holing anyone. But the weak property is still usable when the reference class is available.
To be sure, that this weak property will be alive, we can set a strong cycle in the block.

Answer 1

This doesn't at all do what you think it does. That __weak instance variable in those methods? That's just a shorthand for self->_weak. All of those methods using the proposed manner still capture self strongly.
Stick to what you were doing before.

Answer 2

This is really bad then if the __weakSelf still holds a strong reference. The question is that if instantiated in the method and used in the method does it still really have a weak anchor to self or is it holding a strong reference in that very moment. Based on the documentation you can instantiate a weak reference outside the block and even make it strong inside the block if you want. Take a look here
http://aceontech.com/objc/ios/2014/01/10/weakify-a-more-elegant-solution-to-weakself.html
my question at this point in time is that why does a weak self instantiated dealloc it's self when the real self deallocs..? Because I tried to hold the weak self in another viewController and then dealloc the real self. But the weak self was dealloc as soon as I dealloc the real self.