Is there a way to call a block with a primitive parameter after a delay, like using `performSelector:withObject:afterDelay:` but with an argument like `int`/`double`/`float`?


How do you trigger a block after a delay, like -performSelector:withObject:afterDelay:?

What exactly does the `__block` keyword in Objective-C mean? I know it allows you to modify variables within blocks, but I&#39;d like to know... 

 1. What exactly does it tell the compiler?
 2. Does it do anything else?
 3. If that&#39;s all it does then why is it needed in the first place?
 4. Is it in the docs anywhere? (I can&#39;t find it).

What does the &quot;__block&quot; keyword mean?

I&#39;m getting an error 

&gt;Variable is not assignable (missing __block type specifier)

on the line `aPerson = participant;`. How can I make sure the block can access the `aPerson` variable and the `aPerson` variable can be returned?

    Person *aPerson = nil;
        
    [participants enumerateObjectsUsingBlock:^(id obj, NSUInteger idx, BOOL *stop) {   
        Person *participant = (Person*)obj;
            
        if ([participant.gender isEqualToString:@&quot;M&quot;]) {
            aPerson = participant;
            *stop = YES;
        }
    }];
         
    return aPerson;

Assign a variable inside a Block to a variable outside a Block

Is it possible to have blocks as properties using the standard property syntax?

Are there any changes for **ARC**?

Can I use Objective-C blocks as properties?

Block syntax in Objective C (and indeed C, I presume) is notoriously incongruous. Passing blocks as arguments looks different than declaring blocks as ivars, which looks different than `typedef`ing blocks.

Is there a comprehensive list of block-declaration syntax that I could keep on hand for quick reference?

Block Declaration Syntax List

I have a working app and I&#39;m working on converting it to ARC in Xcode 4.2. One of the pre-check warnings involves capturing `self` strongly in a block leading to a retain cycle. I&#39;ve made a simple code sample to illustrate the issue. I believe I understand what this means but I&#39;m not sure the &quot;correct&quot; or recommended way to implement this type of scenario.

 - self is an instance of class MyAPI
 - the code below is simplified to show only the interactions with the objects and blocks relevant to my question
 - assume that MyAPI gets data from a remote source and MyDataProcessor works on that data and produces an output
 - the processor is configured with blocks to communicate progress &amp; state

code sample:

    // code sample
    self.delegate = aDelegate;
    
    self.dataProcessor = [[MyDataProcessor alloc] init];
    
    self.dataProcessor.progress = ^(CGFloat percentComplete) {
        [self.delegate myAPI:self isProcessingWithProgress:percentComplete];
    };
    
    self.dataProcessor.completion = ^{
        [self.delegate myAPIDidFinish:self];
        self.dataProcessor = nil;
    };
    
    // start the processor - processing happens asynchronously and the processor is released in the completion block
    [self.dataProcessor startProcessing];

Question: what am I doing &quot;wrong&quot; and/or how should this be modified to conform to ARC conventions?

How do I avoid capturing self in blocks when implementing an API?

When using GCD, we want to wait until two async blocks are executed and done before moving on to the next steps of execution. What is the best way to do that?

We tried the following, but it doesn&#39;t seem to work:

    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^ {
        // block1
    });


    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^ {
        // block2
    });

    // wait until both the block1 and block2 are done before start block3
    // how to do that?

    dispatch_sync(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^ {
        // block3
    });


Waiting until two async blocks are executed before starting another block

I&#39;m afraid this question is pretty basic, but I think it&#39;s relevant to a lot of Objective-C programmers who are getting into blocks.

What I&#39;ve heard is that since blocks capture local variables referenced within them as `const` copies, using `self` within a block can result in a retain cycle, should that block be copied. So, we are supposed to use `__block` to force the block to deal directly with `self` instead of having it copied.

    __block typeof(self) bself = self;
    [someObject messageWithBlock:^{ [bself doSomething]; }];

instead of just

    [someObject messageWithBlock:^{ [self doSomething]; }];

What I&#39;d like to know is the following: if this is true, is there a way that I can avoid the ugliness (aside from using GC)?

Retain cycle on `self` with blocks

In Objective-C, you can define a block&#39;s input and output, store one of those blocks that&#39;s passed in to a method, then use that block later:

    // in .h

		typedef void (^APLCalibrationProgressHandler)(float percentComplete);
		typedef void (^APLCalibrationCompletionHandler)(NSInteger measuredPower, NSError *error);

		// in .m

		@property (strong) APLCalibrationProgressHandler progressHandler;
		@property (strong) APLCalibrationCompletionHandler completionHandler;

		- (id)initWithRegion:(CLBeaconRegion *)region completionHandler:(APLCalibrationCompletionHandler)handler
		{
		    self = [super init];
		    if(self)
		    {
		        ...
		        _completionHandler = [handler copy];
		        ..
		    }
    
		    return self;
	}

	- (void)performCalibrationWithProgressHandler:(APLCalibrationProgressHandler)handler
	{
	    ...
           
	            self.progressHandler = [handler copy];
            
	     ...
	            dispatch_async(dispatch_get_main_queue(), ^{
	                _completionHandler(0, error);
	            });
	     ...
	}

So I&#39;m trying to do the equivilant in Swift:

    var completionHandler:(Float)-&gt;Void={}
   
    
    init() {
        locationManager = CLLocationManager()
        region = CLBeaconRegion()
        timer = NSTimer()
    }
    
    convenience init(region: CLBeaconRegion, handler:((Float)-&gt;Void)) {
        self.init()
        locationManager.delegate = self
        self.region = region
        completionHandler = handler
        rangedBeacons = NSMutableArray()
    }

The compiler doesn&#39;t like that declaration of completionHandler. Not that I blame it, but, how do I define a closure that can be set and used later in Swift?



Store a closure as a variable in Swift

Besides the obvious differences:

 - Use `enumerateObjectsUsingBlock` when you need both the index and the object
 - &lt;s&gt;Don&#39;t use `enumerateObjectsUsingBlock` when you need to modify local variables&lt;/s&gt; (I was wrong about this, see bbum&#39;s answer)

Is `enumerateObjectsUsingBlock` generally considered better or worse when `for (id obj in myArray)` would also work? What are the advantages/disadvantages (for example is it more or less performant)?



When to use enumerateObjectsUsingBlock vs. for

How can I pass a `Block` to a `Function`/`Method`?

I tried `- (void)someFunc:(__Block)someBlock` with no avail.

ie. What is the *type* for a `Block`?

Objective-C pass block as parameter

Is it possible to specify a method block parameter in Objective-C without using a typedef?   It must be, like function pointers, but I can&#39;t hit on the winning syntax without using an intermediate typedef:

    typedef BOOL (^PredicateBlock_t)(int);
    - (void) myMethodTakingPredicate:(PredicateBlock_t)predicate

only the above compiles, all these fail:

    -  (void) myMethodTakingPredicate:( BOOL(^block)(int) ) predicate
    -  (void) myMethodTakingPredicate:BOOL (^predicate)(int)

and I can&#39;t remember what other combinations I&#39;ve tried.
   

    

Declare a block method parameter without using a typedef

I have a method that accepts a block and a completion block. The first block should run in the background, while the completion block should run in whatever queue the method was called.

For the latter I always used `dispatch_get_current_queue()`, but it seems like it&#39;s deprecated in iOS 6 or higher. What should I use instead?

Alternatives to dispatch_get_current_queue() for completion blocks in iOS 6?

I often want to execute some code a few microseconds in the future. Right now, I solve it like this:

    - (void)someMethod
    {
        // some code
    }

And this:

    [self performSelector:@selector(someMethod) withObject:nil afterDelay:0.1];

It works, but I have to create a new method every time. Is it possible to use blocks instead of this? Basically I&#39;m looking for a method like:

    [self performBlock:^{
        // some code
    } afterDelay:0.1];

That would be really useful to me.

Blocks instead of performSelector:withObject:afterDelay:

I&#39;m reading Xcode&#39;s documentation, and here is something that puzzles me:

    __block typeof(self) tmpSelf = self;
    [self methodThatTakesABlock:^ {
        [tmpSelf doSomething];
    }];

The following is copied from the documentation:

&gt; A block forms a strong reference to variables it captures. If you use
&gt; `self` within a block, the block forms a strong reference to `self`, so if
&gt; `self` also has a strong reference to the block (which it typically
&gt; does), a strong reference cycle results. To avoid the cycle, you need
&gt; to create a weak (or `__block`) reference to self outside the block, as
&gt; in the example above.

I don&#39;t understand what does &#39;a weak (or `__block`)&#39; mean?

Is

    __block typeof(self) tmpSelf = self;

and

    __weak typeof(self) tmpSelf = self;

exactly the same here？

I found another piece in the document:

&gt; Note: In a garbage-collected environment, if you apply both `__weak` and
&gt; `__block` modifiers to a variable, then the block will not ensure that it is kept alive.

So, I&#39;m totally puzzled.

What is the difference between a __weak and a __block reference?

I have just discovered completion blocks: 


     completion:^(BOOL finished){
                             
    
                         }];

What do I need to do to have my own method take a completion block?


Custom completion block for my own method

I&#39;d like to store objective-c block in a property for later use. I wasn&#39;t sure how to do it so I googled a bit and there is very little info about the subject. But I&#39;ve managed to find the solution eventually and I&#39;ve thought that it might be worth sharing for other newbies like me. 

Initially I&#39;ve thought that I would need to write the properties by hand to use Block_copy &amp; Block_release. 

Fortunately I&#39;ve found out that [blocks are NSObjects][1] and `- copy`/`- release` is equivalent to `Block_copy`/`Block_release`. So I can use `@property (copy)` to auto generate setters &amp; getters.



  [1]: http://developer.apple.com/library/mac/#documentation/cocoa/Conceptual/Blocks/Articles/bxUsing.html#//apple_ref/doc/uid/TP40007502-CH5-SW1

How to store blocks in properties in Objective-C?

I started using blocks a&#160;lot and soon noticed that nil blocks cause bus errors:

    typedef void (^SimpleBlock)(void);
    SimpleBlock aBlock = nil;
    aBlock(); // bus error

This seems to go against the usual behaviour of Objective-C that ignores messages to nil objects:

    NSArray *foo = nil;
    NSLog(@&quot;%i&quot;, [foo count]); // runs fine

Therefore I have to resort to the usual nil check before I use a block:

    if (aBlock != nil)
        aBlock();

Or use dummy blocks:

    aBlock = ^{};
    aBlock(); // runs fine

Is there another option? Is there a reason why nil blocks couldn’t be simply a nop?

Why do nil / NULL blocks cause bus errors when run?

I&#39;ve just run into blocks and I think they are just what I&#39;m looking for, except for one thing: is it possible to call a method [self methodName] from within a block?

This is what I&#39;m trying to do:

    -(void)someFunction{
        Fader* fader = [[Fader alloc]init];

        void (^tempFunction)(void) = ^ {
            [self changeWindow:game]; 
            //changeWindow function is located in superclass
        };

        [fader setFunction:tempFunction];
    }


I&#39;ve been searching for a couple of days and I can&#39;t find any evidence that this is possible.

Is this at all possible, or am I trying to use blocks for something they aren&#39;t meant for?

The reason I&#39;m using blocks is that I&#39;ve created a Fader class, and I want to store a block for it to execute when it finishes fading out. 

Thank you

EDIT:
Okay, I added in the suggestion, but I&#39;m still getting an EXC_BAD_ACCESS error...

    -(void)someFunction{
        Fader* fader = [[Fader alloc]init];

        __block MyScreen* me = self;

        void (^tempFunction)(void) = ^ {
            [me changeWindow:game]; 
            //changeWindow function is located in superclass
        };

        [fader setFunction:tempFunction];
        [fader release];
    }

Maybe I&#39;m not allowed to give *fader* the function...?

Calling [self methodName] from inside a block?

I would like to write a method similar to this:

    +(void)myMethodWithView:(UIView *)exampleView completion:(void (^)(BOOL finished))completion;

I&#39;ve basically stripped down the syntax taken from one of Apple&#39;s class methods for `UIView`: 

    + (void)animateWithDuration:(NSTimeInterval)duration delay:(NSTimeInterval)delay options:(UIViewAnimationOptions)options animations:(void (^)(void))animations completion:(void (^)(BOOL finished))completion;

And would expect it to be used like so:

    [myFoo myMethodWithView:self.view completion:^(BOOL finished){
    					 NSLog(@&quot;call back success&quot;);
    				 }];

My question is how can I implement this?  If someone can point me to the correct documentation that would be great, and a very basic example would be much appreciated (or a similar answer on Stack Overflow -- I couldn&#39;t find one). I still don&#39;t quite know enough about delegates to determine whether that is even the correct approach!

I&#39;ve put a rough example of what I would have expected it to be in the implementation file, but as I can&#39;t find info it&#39;s guess work.

    + (void)myMethod:(UIView *)exampleView completion:(void (^)(BOOL finished))completion {
    	// do stuff
    	
    	if (completion) {
    		// what sort of syntax goes here? If I&#39;ve constructed this correctly!
    	}
    	
    }

Implementing a method taking a block to use as callback

Given the following:

    - (void) someMethod
    {
        dispatch_async(dispatch_get_main_queue(), ^{
            myTimer = [NSTimer scheduledTimerWithTimeInterval: 60
                                                               target: self
                                                             selector: @selector(doSomething)
                                                             userInfo: nil
                                                              repeats: NO];
        });
    }

Where myTimer is declared in a private interface:

    @interface MyClass()
    {
        NSTimer * myTimer;
    }
    @end

How would one fix the following warning:
&lt;pre&gt;Block implicitly retains &#39;self&#39;; explicitly mention &#39;self&#39; to indicate this is intended behavior&lt;/pre&gt;

From what I have found so far, most suggestions involve putting something such as:

    - (void) someMethod
    {
        __typeof__(self) __weak wself = self;
        dispatch_async(dispatch_get_main_queue(), ^{
            wself.myTimer = [NSTimer scheduledTimerWithTimeInterval: 60
                                                               target: self
                                                             selector: @selector(doSomething)
                                                             userInfo: nil
                                                              repeats: NO];
        });
    }

Except, that myTimer is an ivar, meaning `wself` does not have access to any properties.

I guess my questions are:

1. Do/should I care?
2. Should I declare myTimer as a property?

I use ivars quite a bit through my code. I just added the `-Weverything` flag to my project to see if I can find any underlying issues and this is by far the most common warning. I have no problem going though and fixing it by making my ivars properties, but I want to make sure I get a better understanding before I do that.

Block implicitly retains &#39;self&#39;; explicitly mention &#39;self&#39; to indicate this is intended behavior

If I want to pass nothing for an Objective-C block, what keyword should I use, `NULL` or `nil`? I&#39;m asking this because an Objective-C block is an Objective-C object (as I know), but represented as a function pointer.

`NULL` and `nil` both indicate a `0x0` pointer, however they are different semantically. So I&#39;m concerned about this.

Which is the right one, nil or NULL, to mark &quot;no Objective-C block&quot;?

I looked around, but couldn&#39;t find this on the internet, nor anywhere in the Apple docs, so I&#39;m guessing it doesn&#39;t exist.

But is there a iOS4 blocks equivalent API to:

    [button addTarget:self action:@selector(tappy:) forControlEvents:UIControlEventTouchUpInside];

I suppose this could be implemented using a category, but would rather not write this myself due to *extreme* laziness :)

Something like this would be awesome:

    [button handleControlEvent:UIControlEventTouchUpInside withBlock:^ { NSLog(@&quot;I was tapped!&quot;); }];

UIButton block equivalent to addTarget:action:forControlEvents: method?

I need to dispatch a block on the main queue, synchronously. I don’t know if I’m currently running on the main thread or no. The naive solution looks like this:

    dispatch_sync(dispatch_get_main_queue(), block);

But if I’m currently inside of a block running on the main queue, this call creates a deadlock. (The synchronous dispatch waits for the block to finish, but the block does not even start running, since we are waiting for the current one to finish.)

The obvious next step is to check for the current queue:

    if (dispatch_get_current_queue() == dispatch_get_main_queue()) {
        block();
    } else {
        dispatch_sync(dispatch_get_main_queue(), block);
    }

This works, but it’s ugly. Before I at least hide it behind some custom function, isn’t there a better solution for this problem? I stress that I can’t afford to dispatch the block asynchronously – the app is in a situation where the asynchronously dispatched block would get executed “too late”.

How to dispatch on main queue synchronously without a deadlock?

I ran into a scenario where I had a delegate callback which could occur on either the main thread or another thread, and I wouldn&#39;t know which until runtime (using `StoreKit.framework`).

I also had UI code that I needed to update in that callback which needed to happen before the function executed, so my initial thought was to have a function like this:

    -(void) someDelegateCallback:(id) sender
    {
        dispatch_sync(dispatch_get_main_queue(), ^{
            // ui update code here
        });

        // code here that depends upon the UI getting updated
    }

That works great, when it is executed on the background thread. However, when executed on the main thread, the program comes to a deadlock.

That alone seems interesting to me, if I read the docs for `dispatch_sync` right, then I would expect it to just execute the block outright, not worrying about scheduling it into the runloop, as said [here](https://developer.apple.com/library/mac/documentation/Performance/Reference/GCD_libdispatch_Ref/Reference/reference.html#//apple_ref/c/func/dispatch_sync):

 &gt; As an optimization, this function invokes the block on the current thread when possible.

But, that&#39;s not too big of a deal, it simply means a bit more typing, which lead me to this approach:

    -(void) someDelegateCallBack:(id) sender
    {
        dispatch_block_t onMain = ^{
            // update UI code here
        };

        if (dispatch_get_current_queue() == dispatch_get_main_queue())
           onMain();
        else
           dispatch_sync(dispatch_get_main_queue(), onMain);
    }

However, this seems a bit backwards. Was this a bug in the making of GCD, or is there something that I am missing in the docs?

Why can&#39;t we use a dispatch_sync on the current queue?

I read a lot of posts about using `__weak self` inside `dispatch_async`, and now I am a litle bit confused.

if I have :

    self.myQueue = dispatch_queue_create(&quot;com.biview.core_data&quot;, NULL);

    dispatch_async(self.myQueue, ^(void){
        if (!self.var1) {
            self.var1 = ...;
        }
        dispatch_async(dispatch_get_main_queue(), ^(void) {
            if ([self.var2 superview]) {
                [self.var2 removeFromSuperview];
            }
            
            [self.Label setText:text];
        });
    });

do I need to use `__weak self`. Because I read that in some cases `dispatch_async`   not need a `__weak self`.

[See last comment here][1]


  [1]: https://stackoverflow.com/questions/8806193/when-and-why-would-i-want-to-declare-a-local-variable-as-weak-using-arc

Using weak self in dispatch_async function

Bear with me, this is going to take some explaining. I have a function that looks like the one below.

Context: &quot;aProject&quot; is a Core Data entity named LPProject with an array named &#39;memberFiles&#39; that contains instances of another Core Data entity called LPFile. Each LPFile represents a file on disk and what we want to do is open each of those files and parse its text, looking for @import statements that point to OTHER files. If we find @import statements, we want to locate the file they point to and then &#39;link&#39; that file to this one by adding a relationship to the core data entity that represents the first file. Since all of that can take some time on large files, we&#39;ll do it off the main thread using GCD.



    - (void) establishImportLinksForFilesInProject:(LPProject *)aProject {
        dispatch_queue_t taskQ = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
         for (LPFile *fileToCheck in aProject.memberFiles) {
             if (//Some condition is met) {
                dispatch_async(taskQ, ^{
                    // Here, we do the scanning for @import statements. 
                    // When we find a valid one, we put the whole path to the imported file into an array called &#39;verifiedImports&#39;. 
                
                    // go back to the main thread and update the model (Core Data is not thread-safe.)
                    dispatch_sync(dispatch_get_main_queue(), ^{
                                
                        NSLog(@&quot;Got to main thread.&quot;);
                                
                        for (NSString *import in verifiedImports) {  
                                // Add the relationship to Core Data LPFile entity.
                        }
                    });//end block
                });//end block
            }
        }
    }



Now, here&#39;s where things get weird:

This code works, but I&#39;m seeing an odd problem. If I run it on an LPProject that has a few files (about 20), it runs perfectly. However, if I run it on an LPProject that has more files (say, 60-70), it does **NOT** run correctly. We never get back to the main thread, the `NSLog(@&quot;got to main thread&quot;);` never appears and the app hangs. BUT, (and this is where things get REALLY weird) --- if I run the code on the small project FIRST and THEN run it on the large project, everything works perfectly. It&#39;s ONLY when I run the code on the large project first that the trouble shows up.

And here&#39;s the kicker, if I change the second dispatch line to this:

    dispatch_async(dispatch_get_main_queue(), ^{

(That is, use `async` instead of `sync` to dispatch the block to the main queue), everything works all the time. Perfectly. Regardless of the number of files in a project! 

I&#39;m at a loss to explain this behavior. Any help or tips on what to test next would be appreciated. 

dispatch_sync vs. dispatch_async on main queue

In Objective-C, I know that blocks are considered objects, so I was wondering if it was possible to store them in an array.  This begs the question, are blocks first class objects or are they just treated like objects for the sake of passing them between objects?  If they are first class objects, then shouldn&#39;t they be storable in arrays?  

Storing Blocks in an Array

I have a long running loop I want to run in the background with an `NSOperation`. I&#39;d like to use a block:

    NSBlockOperation *operation = [NSBlockOperation blockOperationWithBlock:^{
       while(/* not canceled*/){
          //do something...
       }
    }];
The question is, how to I check to see if it&#39;s canceled. The block doesn&#39;t take any arguments, and `operation` is nil at the time it&#39;s captured by the block. Is there no way to cancel block operations?

All Objective C-Blocks Solutions on Gang of Coders

Total of 29 Objective C-Blocks Solutions