Hi. My named is Amit,@paradoxed on Twitter.

So today we're gonna talk about delegation.

Delegation is a very common design pattern used all over when programming an iOS app.

If you've done any of our courses like the Blog Reader project or the Ribbit

app, you've noticed that within the table

View Controller, you have the table view delegate.

And then if you've used a scroll view or a text field,

you've probably used a delegate to go along with that.

So we've used delegate all over the places but we've

never specifically addressed what is the delegate, a design pattern.

Now a delegate or a protocol is basically something that defines

a bunch of methods that can be implemented by any class.

It's the most common design pattern and it means, to delegate control.

So you

are basically giving over control and having

that class implement the functionality of that method.

So let's take a look at how you can

define a protocol, and then implement that in a class.

Alright, I've created a sample app over

here, and, basically it's a single view application.

Let me run the app.

And what you'll see is that there's a button here.

Which says, press me, and then a text is displayed on the text label.

So the way this app is designed is that if I go to the main story board you won't see

anything because it's just a simple view, so there is

our view controller and it has the main view in it.

And let me go to the ViewController.m and you'll see that

it has a property called THCustomView and

all I do is add this custom view as a sub view to my

main view. Now this custom view, let's head on over

to customview.h, as you can see the interface, all it has

is a method called set text where you can set the text of the

label in the custom view.

Now, the, this is assuming that you have created this custom view

that you want to reuse it in multiple places throughout your application.

And you do not want to give direct access to the button or the label.

You just want the person using the custom view to set the

text and then you want to control the look and feel and

the color and all the other attributes of the controls that are housed

within this custom view. Now of course, as a contrived example,

I'm just trying to drive home the point that if you create a complex view

that can be reused throughout your application or you're creating a third

party component so that other people can use it or opensource

this component.

And you don't want to give completely control over all the controls within that

custom view, then what happens is that when a button is pressed.

Now, it's assuming that you, you can, of course, expose the button press method

and set target actions to other view controllers, but the way this custom

control is designed is that you have a button press method with that, within the

custom view, so it's setting itself a text when the button is pressed.

Now, inside the THView controller.m, I actually

want to receive that button pressed event.

I want to know when that button was pressed within the custom

view, so that I can go ahead and call that set text method.

I can simply set the text, but that doesn't help me because

I want to set the text only if the button has been pressed.

Now how do, how does the custom view

instruct the THviewController that the button was pressed.

Right now there's no way of doing that unless we expose the button

as a public property. Right now it's a private property.

Both of these are private properties.

But let's say you've created a, a custom

view and you don't wanna expose these things

as, public properties because you don't want them

to manipulate the look and feel of your control.

So, in the init frame, basically, we are setting the frame for the

button and adding it as a sub-view and the same thing we're doing

for the label.

Now the only way we can do this is if we create a delegate object that

delegates the responsibility of the button-press method to its delegate.

So the only way we can do that is if we create a delegate object within our

custom view that would delegate the responsibility of the button

press method to its delegate. So how do we go

about doing that? Well let's take a look, so, the first

thing I would need in my interface is a delegate object.

So we'll say at property nonatomic, and this would be weak, this is the

perfect example of using a weak property you will see that in a little

bit why it's a weak property and not very strong.

So, I have defined this delegate which is of type id.

We, we don't specify exactly what this is, because we

don't know what kind of delegate it's going to be.

It could be a view controller, it could be another view, it

could be a table view controller, it could be a scroll view.

Anything could be a

delegate of this custom view.

We don't know what could be the delegate, that's why it's an id, which means that

the type of this object is going to be determined at run time.

So, the next thing we need to do is define a protocol.

Now a protocol as its, as the name states, is, is

a set of methods that can be implemented by a delegate.

So the delegate needs some sort of structure, the

delegate just can't be like, well I am going

to do x, y and z, no, the delegate

needs some set up instructions that it can implement.

So we need to define what those instructions look like.

So you need to declare the instructions, which is a

protocol, and then that protocol is implemented by your delegate.

So we will declare our protocol right here in our THCustomView.

So it's after the interface implementation.

So, as you can see, after the end, @end over here.

So we need to give our protocol a name. So, the protocol names are basically the

name of the class that needs a protocol followed by the suffix delegate.

Now, it's usually a protocol on NSObject, so we'll leave that as is.

And then we define our methods.

Now similarly, as you define methods in your @interface, you

can have class methods or you can have instance methods.

So I'll create a instance method called buttonPressed.

Now mind you, this can be called anything you want.

I'm simply calling it buttonPressed because we're

delegating that button pressed action to our delegate.

Alright, so now that we've defined our protocol, it's always

good practice to define what kind of delegate this is.

So, as you can see in these angle brackets

over here, you specified NSObject, which means that the

protocol is of type NF, NSObject. Similarly, you can mention

that this delegate should only be of type THView custom delegate.

You don't want the other class just implementing any kind of delegate

and hoping that this will work, cuz otherwise you'll get a run-time error.

At least when you put

this here, you will get a compiler warning if that delegate hasn't been specified.

We'll come to it when we actually define the delegate in the view controller.

So you'll get a better understanding of why I'm doing this.

Now of course, we're getting an error

here saying that, cannot find protocol declaration.

That's because our protocol is defined after

the@Interface, so one way we can prevent that

error is just cause copying the @protocol ThCustomViewDelegate.

Just as we define an @class, which is a forward declaration, that

hey, this is a class that's going to be implemented in the future.

Similarly we can specify a forward declaration for our protocol.

So basically we're telling the compiler that this is a forward

declaration for a protocol and we're gonna declare it later on somewhere.

And later on, in this case, is right after our @interface declaration.

So, here we have actually created our own, very own protocol.

Now you've must have seen these protocols with

table view controllers or scroll views or text fields.

There are so many delicates defined for you in the UIKit framework.

And here we are defining our very own delegate.

So let's go ahead and see how we can implement this delegate.

So, when we go back to our THViewController.m, and

here in our self.customView, we can refer to that delegate property.

So .customView.delegate

and here we can just specify self.

Because we're saying we are going to be the delegate for the custom view.

We're gonna take over the responsibility of that button

press method, or any other methods the protocol provides.

So, as you can see here, I get a compiler warning and if I click here it says

assigning id THCustomViewDelicate from incompatible type, so that's

why we specify the THCustomViewDelegate in angle brackets.

Because it's saying like, are you really haven't implemented this delegate.

And by implementing, we have to go to the

interface definition of our view controllers.

So let's go to the .h file.

And here is where we specify THCustomViewDelegate.

So that's where we need to specify it and as you can see, we get an error saying

that it cannot find the protocol. So let's Import our THCustomView.

So that error will go away.

And so now when we go back to

our implementation, we don't get the error anymore.

You know, it, it's satisfied that you're gonna be implementing this delegate.

Now, we get another warning here, saying

that method, buttonPressed in protocol not implemented.

That's because we have to implement the methods required

by our protocol.

So, here we'll go and define the button press method.

So we'll say self.customView set text.

And let's set the text, we'll say button pressed

view controller.

So, are we done?

Well, let's run our application and see if this works,

and it won't work but let me show you anyway.

So it says button pressed custom view, and

it should really be saying, button pressed view controller.

Let me remove this space here so that work's consistent.

So why doesn't it work?

We've set our delegates, we've set our button pressed methods.

Well.

All that is fine. We've defined our protocol and

we've set the delegate, but somewhere in our THCustomView implementation,

we need to instruct it that it needs to delegate that buttonPressed method.

We aren't delegating that responsibility anywhere.

So, as you can see, in this buttonPressed method, we're simply setting the text.

So this is the last piece of the puzzle where we check our delegate object,

so we'll say, if self.delegate

responds to selector, so here we're checking to see

if our delegate actually has this method. Does it have this

method implemented, buttonPressed and if it does,

then let's delegate that buttonPressed method, to the method of our delegate.

So there is another method, called perform selector.

So if you were passing an argument, you could use perform selector with object.

In our case, we are not passing an argument so

we will just say perform selector and then add selector, buttonPressed.

So basically what this is doing here is performing this method of our delegate.

And in this case, our delegate is our view controller, could it be something else?

Sure, it could be any other class. And I will say else,

so if it doesn't respond to the buttonPressed

method, then we're just gonna do our default action.

You don't have to do this but I just wanted to show

that you can have default behavior or you could have delegated behavior.

So now if we run our application and I hit Press Me,

you'll notice that it says, button pressed: view controller, as it should.

So going back to our code, one last thing that you want to note is

that in our protocol we can define some of the methods as optional.

As you notice that when we didn't define any of these methods

as optional, the compiler complains saying

that we hadn't implemented the buttonPressed method.

So, how do you define it as optional? Well, you can

just simply put the keyword @optional and basically it'll say whatever

methods follow this @optional definition these methods will be optional.

So now if we go back to our view controller implementation and I remove the

implementation of the buttonPressed method, you'll notice

that I don't get a compiler warning anymore.

And if I run my application,

it's simply going to use the default behavior.

Basically, buttonPressed custom view, so that buttonPressed custom view

is coming from my custom view and not the delegate.

So there you have it.

This is what delegates are all about.

They're about delegating control or responsibility to another class.

Now this doesn't have to be between views

or controls, this could be between view controllers or

your custom class.

So, don't think that you're restricted to

just UIView subclasses when creating a delegate.