Question

I am an average iOS developer. The first design pattern that I saw heavily being used was Delegation pattern which was mostly being used for callback functionality.

Now that blocks are there in Objective C and I am seeing more and more libraries heavily using them and avoiding delegates, I am wondering, are blocks permanent replacement for delegate pattern using protocols ?

I recently used MKNetworkKit in a project, I created a wrapper class on top of it, the library is block based so all my code that would encapsulate a call to one of there block based code turned ot to be another block based code.

I found that it was very convenient initially, but was difficult to debug and modify as the code looked complex (callback inside callback inside callback!)

Any tips on when to use what and certain best practices ?

Answer 1

Delegates and blocks are both used for something to “call back” the result, usually to the thing that created it. There are some differences:

• Using a delegate protocol, the method names you must implement to receive the callback are fixed. That means, if you need to receive callbacks from multiple possible actions using the same delegate protocol, you must somehow distinguish them. With blocks, there are no fixed names; you simply pass a block object with a particular signature. You can pass different block objects to different actions.
• Delegate protocols often (but not always) contain more than one callback method, e.g. a “success” and a “failure” callback. Each block can only serve as one callback. Many libraries try to “combine” multiple delegate callbacks into a single block callback, by using multiple arguments, e.g. the block has two arguments (result, error), where if “error” is nil it corresponds to the original “success” callback, with “result” being the data; and if “error” is not nil, it corresponds to the original “failure” callback. Another option would be to give multiple blocks separately to the action (e.g. it has a “success block” property, and “failure block” property, which you can set). This is more general, and will work as a one-to-one replacement of a delegate protocol with any number of methods.
• Memory management: Delegates are usually weakly-referenced, since the delegate is usually a “parent” object that owns the delegator. However, blocks are strongly referenced, since blocks are one-use things that are not needed anymore once passed to the delegator. However, if you think about it, it is not really different. With delegates, typically the delegate method will perform some action on itself (the parent object). With blocks, in order to do this, the block would need a reference to the “parent”. It is then this reference that needs to be a weak reference, to emulate the memory management of the delegate pattern. With blocks, the parent object code has more control over how the delegate will reference it, because it sets up the block.

In conclusion, it is possible to systematically convert any API using a delegate protocol into one that uses blocks, with what I described above — for each delegate method, add one block property on the delegator.