Swift delegate design pattern

The delegate design pattern is a relatively easy way to communicate between two objects through a common interface, protocol in Swift.

Design patterns

Implementing delegation in Swift

You'll need a delegate protocol, a delegator who actually delegates out the tasks and a delegate object that implements the delegate protocol and does the actual work that was requested by the "boss". Let's translate this into human.

The client reports a bug. The project manager creates an issue and tells one of the developers to fix the problem asap.

See? That's delegation. At some point an event happened, so the delegator (manager) utilized an external resource (a developer) using a common interface (issue describing the problem for both party) to do achieve something (fix the ๐Ÿ›).

To demonstrate how delegation works in real life I made a pretty simple example. I'm going to use a similar approach (because Xcode playgrounds are still freezing every 1-5 minutes) like I did for the command pattern, but the purpose of this one is going to be almost entirely different, because we're talking about delegation. ๐Ÿ˜…

#!/usr/bin/env swift

import Foundation

protocol InputDelegate {

    var shouldContinueListening: Bool { get }

    func didStartListening()
    func didReceive(input: String)

class InputHandler {

    var delegate: InputDelegate?

    func listen() {

        repeat {
            guard let input = readLine() else {
            self.delegate?.didReceive(input: input)
        while self.delegate?.shouldContinueListening ?? false

struct InputReceiver: InputDelegate {

    var shouldContinueListening: Bool {
        return true

    func didStartListening() {
        print("๐Ÿ‘ป Please be nice and say \"hi\", if you want to leave just tell me \"bye\":")

    func didReceive(input: String) {
        switch input {
        case "hi":
            print("๐ŸŒŽ Hello world!")
        case "bye":
            print("๐Ÿ‘‹ Bye!")
            print("๐Ÿ” Command not found! Please try again:")

let inputHandler = InputHandler()
let inputReceiver = InputReceiver()
inputHandler.delegate = inputReceiver

This is how you can create your own delegate pattern in Swift. You can imagine that Apple is doing the same thing under the hood, with UICollectionViewDataSource, UICollectionViewDelegate etc. You only have to implement the delegate, they'll provide the protocol and the delegator. ๐Ÿค”

Weak properties, delegates and classes

Memory management is a very important thing so it's worth to mention that all the class delegates should be weak properies, or you'll create a really bad reatin cycle. ๐Ÿ˜ฑ

protocol InputDelegate: class { /*...*/ }

class InputHandler {

    weak var delegate: InputDelegate?


class InputReceiver: InputDelegate {

Here is the altered Swift code snippet, but now using a class as the delegate. You just have to change your protocol a little bit and the property inside the delegator. Always use weak delegate variables if you are going to assign a class as a delegate. โš ๏ธ

As you can see delegation is pretty easy, but it can be dangerous. It helps decoupling by providing a common interface that can be used by anyone who implements the delegate (sometimes data source) protocol. There are really amazing articles about delegates, if you'd like to know more about this pattern, you should check them out.

Share this article on Twitter.
Thank you. ๐Ÿ™

Picture of Tibor Bรถdecs

Tibor Bรถdecs

Creator of https://theswiftdev.com (weekly Swift articles), server side Swift enthusiast, full-time dad. -- Follow me & feel free to say hi. ๐Ÿค˜๐Ÿป -- #iOSDev #SwiftLang

Twitter · GitHub


100% Swift news, delivered right into your mailbox

Updates about the latest Swift news including my articles and everything what happened in the Swift community as well.

Subscribe now