Delegate in iOS

Delegation is a simple and powerful pattern in which one object in an app acts on behalf of, or in coordination with, another object. The delegating object keeps a reference to the other object—the delegate—and at the appropriate time, the delegating object sends a message to the delegate. The message informs the delegate of an event that the delegating object is about to handle or has just handled. The delegate may respond to the message by updating the appearance (or state) of itself or of other objects in the app, and in some cases it will return a value that affects how an impending event is handled.

A common design uses delegation to allow a child view controller to communicate a value (typically a user-entered value) to its parent view controller.

The idea behind delegates is that instead of class A executing some code, it tells it’s delegate to execute that code.  The delegate is tied to another class (let’s call it class B).  In order to facilitate this, class A creates something called a protocol.  This protocol has a list of methods in it (with no definition).  Class A then has an instance of the protocol as a property.  Class B has to implement the protocol defined in class A.  Lastly, when class A is created, it’s delegate property is set to class B. 

Example:

Let’s say we have two objects, Brain and Beer Bottle, Brain is the object we use to manage the entire Body application, it handles all of the important tasks such as poop, eat, drink, sleep etc. Beer Bottle is attached to body but it doesn’t know what Brain is thinking, likewise, Brain has no idea what Beer Bottle is thinking.

Brain is using Beer Bottle’s attributes to satisfy itself while it’s watching TV, but the problem is that brain is so distracted by the tv that it can’t pay attention to when beer is going to run out. This could all end in disaster, Brain needs to know when beer is empty so that it send body to the fridge and initialize another instance of Beer Bottle.

Brain can use the drink function to lower Beer Bottles liquid variable, but once liquid reaches 0, Brain needs to know about it, this is where delegates come into action, we can use a Beer Bottle Delegate. Brain can listen out for the Beer Bottle Delegate telling brain that the bottle is empty, all we need to do is simply tell Brain to listen out for Beer Bottle telling it’s delegate that is empty and Brain can react to it. This well thought out and illustrated diagram shows all of this in action:

Creating Custom Delegates: 

For example we want to send a message to application when printing job is done in order to take appropriate action based on the message.

1) interface file

#import <Foundation/Foundation.h>

@class Printer

@protocol PrinterDelegate <NSObject>

-(void) FinishPrint;

@end

@interface Printer:NSObject{

id<PrinterDelegate> delegate;

}

@property(nonatomic, strong) id<PrinterDelegate> delegate;

-(void) printData;

@end

2) Implementation File

#import Printer.h

@implementation

@synthesize delegate; 

-(id)init{  // initialization code }

-(void)printData{

// printing instruction

[delegate performSelector@selector(finishPrint)];

}

@end

3) Finally , the class that implements printerDelegate, might have its own interface like this:

#import <UIKit/UIKit.h>

#import Printer.h

@interface MyViewController : UIViewController<PrinterDelegate>

@end

Now in implementation file we must implement the finishPrint method as:

-(void)viewDidLoad{

Printer *printer = [Printer alloc]init];

printer. delegate =  self;

}

-(void)finishPrint{

NSLog(@"printing has been done successfully");

}

References:

https://developer.apple.com/library/ios/referencelibrary/GettingStarted/RoadMapiOS/DesignPatterns.html
http://enroyed.com/ios/delegation-pattern-in-objective-c-and-writing-custom-delegates/