iOS Delegates Tutorial

Key Steps to Delegation

The delegation design pattern has long been a core competency for Cocoa programmers. This remains the case with the arrival of Swift. Regardless of whether you are using Objective-C or Swift the basic steps to use delegation are the same:

1. Create a delegate protocol that defines the responsibilities of the delegate.
2. Create a delegate property in the delegating class to keep track of the delegate.
3. Adopt and implement the delegate methods in the delegate class.
4. Call the delegate from the delegating object.

Note that there are a couple of differences between Swift and Objective-C support for delegates:

• Swift allows protocols to be used by classes, structs or enums. In Objective-C we are limited to classes. This changes whether we use reference semantics (classes) or value semantics (structs and enums) for the delegate.
• Objective-C supports optional protocol methods. Swift only allows optional protocol requirements if you mark the protocol with the @objc attribute. If you use @objc you can then only use the protocol with class types.

Create the Delegate Protocol

Let’s create a delegate protocol that a view controller might use to tell a parent or master view controller that a task has finished.

In Objective-C:

@protocol DetailViewControllerProtocol <NSObject>
- (void)didFinishTask:(DetailViewController *)sender;
@end

The Swift code is similar:

protocol DetailViewControllerDelegate: class {
  func didFinishTask(sender: DetailViewController)
}

Notes:

• The class keyword in the Swift protocol definition limits protocol adoption to class types (and not structures or enums). This is important if we want to use a weak reference to the delegate as will see next.
• I changed the above code to include the sender in the delegate message as is common practise (thanks to @salutis for keeping me straight).

Add a Delegate Property

Our delegating class needs a reference to the delegate - but should it be a strong or weak reference? We need to pay attention not to create a retain cycle between the delegate and the delegating objects. That can happen if our delegate already has a strong reference to our delegating object. In that case we should make our delegate a weak reference. In Objective-C we do that as follows:

@property (weak) id<DetailViewControllerProtocol>delegate;

Since we do not always set a delegate we use an optional property in Swift:

weak var delegate:DetailViewControllerDelegate?

Notes:

• The use of a weak delegate in Swift is only allowed when we have a class protocol. Xcode will complain if you try to use a weak reference to a non-class protocol since structures and enums use value not reference semantics.
• Using an optional type for the delegate in Swift also means it is automatically set to nil.

Adopt and implement the Delegate Protocol

In our delegate class we tell the compiler that we are adopting the protocol and then implement the delegate method(s). In Objective-C we can use a category to declare the protocol conformance:

@interface MasterViewController () <DetailViewControllerDelegateProtocol>
@end

- (void)didFinishTask:(DetailViewController *)sender {
  // do stuff like updating the UI
}

For the Swift equivalent code we can use an extension to the master view controller class to declare and implement the delegate function:

extension MasterViewController: DetailViewControllerDelegate {
  func didFinishTask(sender: DetailViewController) {
    // do stuff like updating the UI
  }
}

We also need to remember to set the delegate somewhere. This might be in a prepareForSegue or target-action method that will present the detail view controller:

// Objective-C
detailViewController.delegate = self;

// Swift
detailViewController.delegate = self

Calling Delegate Methods

Finally we can call the delegate from our delegating class. In Objective-C we avoid checking the delegate is set since sending a message to nil does no harm. (If you have optional methods use respondsToSelector: to first test if it is implemented by the delegate):

[self.delegate didFinishTask:self];

In Swift we can use optional chaining to achieve a similar effect. Only if the delegate is not nil do we call the delegate method:

delegate?.didFinishTask(self)