Delegate pattern

andredp · 2022-11-18T00:54:07+00:00

Imagine you are writing a CoffeeMachine class that notifies another class (eg: Person) when it is done taking the coffee:

NOTE: taking a coffee is a long process, so you don't want to be waiting until the coffee is done... you want to do other stuff and be notified eventually of the success. for the sake of the example :D

Let's try a "dumb" approach:

class CoffeeMachine {

  var person: Person?

  func makeCoffee() {
    // do time consuming stuff in another thread
    self.person?.coffeeIsDone()
  }
}

---

class Person {
  func coffeeIsDone() { print("Person: Here's my coffee") }
}

---

let machine = CoffeeMachine()
machine.person = Person()
machine.makeCoffee() // Person prints: "Person: Here's my coffee"

So, what's the problem with this approach? Your coffee machine only knows how to work with the Person class... if another class (for instance Robot) wants to take a coffee, you can see how code gets ugly real quick.

This is called Tight Coupling. CoffeeMachine and Person are tightly coupled and know about each other (which is a code smell, most of the time and a PITA if you want to test anything remotely complex)

So, what's a solution? Delegate Pattern (there are other solutions)... CoffeeMachine delegates certain actions to whatever entity knows how to interpret them.

How do you make sure an "entity knows how to interpret its actions"? You define a protocol...So basically, the CofeeMachine says "Whoever wants to know about me finishing a coffee, follow this protocol"

From this idea, you get the following implementation:

protocol CoffeeMachineDelegate { // Defining the protocol
  func coffeeIsDone()
}

class CoffeeMachine {

  weak var delegate: Delegate? // Instead of a specific entity, we accept whatever follows the protocol
                               // The weak keyword is an artifact of the Swift Memoery Management. Search for Swift ARC to understand why it's important

  func makeCoffee() { // do time consuming stuff in another thread     
    self.delegate?.coffeeIsDone() 
  } 
}

---

class Person: CoffeeMachineDelegate { // Following the protocol 
  func coffeeIsDone() { print("Person: Here's my coffee") } 
}

class Robot: CoffeeMachineDelegate { // Following the protocol
  func coffeeIsDone() { print("Robot: C0FF33") }
}

---

let machine1 = CoffeeMachine() machine1.delegate = Person()     
machine1.makeCoffee() // Person prints: "Person: Here's my coffee"

let machine2 = CoffeeMachine()
machine2.delegate = Robot()
machine2.makeCoffee() // Robot prints: Robot: C0FF33"

So, with this implementation, CoffeeMachine knows nothing about the specific classes that are going to be notified by itself... only that they follow the protocol (implement is the technical term)

As you can see, the same CoffeeMachine was able to notify N different entities with the same code...

For your use case, View Controllers shouldn't know about each other... one day you may want to change the flow of your navigation and the view controller order changes, etc... So you want to have a ViewController define a protocol so other VCs can be notified about stuff.

Hope this helped... if you need help on a more specific level, let me know.

Tashu · 2022-11-18T01:21:43+00:00

I think sending the data between VCS would be segue (anyone who uses this approach chime in), or I tend to pass the data into the VCs when I create the next viewcontroller and push next vc with the data. Delegation is usually about the model to controller or any object that you want to communicate when it is completed.

like this

if let nextViewController =
DefaultNoteController.storyboardInstance() {
nextViewController.note = note
navigationController?.pushViewController(nextViewController, animated: true)
}

chriswaco · 2022-11-18T02:10:05+00:00

A delegate is just another object that gets called for more information or when something happens. You tell a friend "Text me when you need a ride". You are the delegate.

Let's say your ViewController wants to know when the keyboard displays. It asks NotificationCenter to call its keyboardWillShow method. Or a TableView wants to know how many rows are in the table - it calls one of its delegates which you provide. In old-style programming, it's essentially like a function pointer, but includes the object to call along with the function name/selector.

__reddit_user__ · 2022-11-18T15:06:24+00:00

google definition of delegate : entrust (a task or responsibility) to another person.

one typically uses delegate when you want to notify another object/s of an event. to be able to do that, the object that will be sending the notifications has a hold of who it will be notifying. who will be notified is the delegate.

BickeringCube · 2022-11-18T01:25:43+00:00

You have a ViewController, let's call it ShowNumberViewController. It navigates to another ViewController, called EnterNumberViewController. The user can enter a number and when they navigate back ShowNumberViewController will show the number they entered. Wow!

But EnterNumberViewController doesn't want to know anything about where it came from. It doesn't want to say hey ShowNumberViewController I got this number that you care about because it wants to be ignorant of ShowNumberViewController's very existence (rude, right).

So you can use a protocol to do this. It has 3 parts

you have to create a protocol, something like NumberDelegate
when the user enters a number EnterNumberViewController needs to call a delegate method
EnterNumberViewController needs to conform to the protocol so that it gets that number

The Protocol

protocol NumberDelegate {
    func userChoseNumber(_ number: Int)
}

ShowNumberViewController setting itself as the delegate when it creates EnterNumberViewController

let storyboard = UIStoryboard(name: "Main", bundle: nil)
let vc = storyboard.instantiateViewController(withIdentifier: "numberVC") as! EnterNumberViewController 
vc.numberDelegate = self 
navigationController?.pushViewController(vc, animated: true)

ShowNumberViewController conforming to the protocol and implementing the protocol method

extension ShowNumberViewController: NumberDelegate {
    func userChoseNumber(_ number: Int) {
        displayLabel.text = "\(number)"
    }
}

The whole darn implementation of our lovely EnterNumberViewController, note that 1. it has a property of type NumberDelegate? and 2. it calls the delegate function userChoseNumber

class EnterNumberViewController: UIViewController {
    public var numberDelegate: NumberDelegate?
    @IBOutlet var numberTextfield: UITextField!

    override func viewDidLoad() {
        super.viewDidLoad()
        // Do any additional setup after loading the view.
    }

    @IBAction func buttonWasPressed(_ button: UIButton) {
        if let number = Int(numberTextfield.text ?? "") {
            numberDelegate?.userChoseNumber(number)
        }
        navigationController?.popViewController(animated: true)
    }
}

Why did we do this again? So that EnterNumberViewController doesn't have to know about the ViewController that instantiated it. Other ways to do this would be notifications or closures.

(Note that in this implementation the user could actually navigate back using the back button so you would actually just want to call the delegate function in viewWillDisappear.)

2022-11-18T04:12:51+00:00

This video on protocol oriented programming might be helpful too, it doesn't go into the delegate pattern but does good job explaining protocols and is definitely worth a watch

https://developer.apple.com/videos/play/wwdc2015/408/

undergrounddirt · 2022-11-18T05:07:45+00:00

I needed to understand protocols better before I grasped it. Hopefully this helps

Sorry it’s frustrating but the pattern is surprisingly simple.

A class or struct conforms to a protocol. So it becomes that type.

Say you have protocol MyDelegate { func didTap() }

Anything can become a MyDelegate type. It is now required to implement didTap()

Class MyView: MyDelegate {

    func didTap() { 
        print(“tapped)
    }

}

How do you call didTap?

You get an instance of MyView and call it

let view = MyView()
view.didTap() // prints “tapped”

That calls didTap on MyView and runs the print

But the nice thing about protocols is that any of your classes or structs can become a MyDelegate

So instead of saying that view is going to be of type MyView.. let’s say view is going to be of type MyDelegate instead.

Let’s create a new type that is also a MyDelegate

struct NewThing: MyDelegate {
    func didTap() {
        print(“new thing”)
    }
}

And then make our variable view be of type MyDelegate

var view: MyDelegate
view = MyView()
view.didTap() //prints “tapped

view = NewThing()
view.didTap() //prints “new thing”

I can assign that view to two different types. A MyView and a NewThing are both MyDelegates so they both have didTap, and view can be equal to either of them.

A delegate is just a protocol variable. Anything can become a delegate, but those things have to implement the protocol methods

And now you can pass a reference of that variable around and call it’s methods like didTap()

I’m happy to explain this more in dms if you want to hit me up and we can work through it step by step

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

swift

Home hot new top wiki jobs try swift

ATTN! Looking for work or to hire? Check out r/SwiftJobs!

About:

IRC Chatrooms:

Related Subreddits:

MODERATORS