Swift - Delegate

Links

Swift (Programmiersprache)
Swift - Protocols

Das Delegate Design Pattern

Das Delegate Design Pattern ist eine Möglichkeit, wie man bestimmte Aufgaben oder Verhaltensweisen von einem Objekt an ein anderes Objekt delegieren kann. Stell dir vor, du bist der Lehrer einer Schulklasse und du möchtest, dass ein Schüler als Klassenvertreter fungiert und bestimmte Aufgaben für die Klasse übernimmt. Der Schüler wäre in diesem Fall der Delegat und du wärst der Delegierende. Du gibst bestimmte Aufgaben an den Schüler ab, anstatt sie selbst zu erledigen. Auf diese Weise kannst du die Verantwortung für bestimmte Aufgaben teilen und dich auf andere wichtige Dinge konzentrieren.

Das Delegate Design Pattern wird auch in der Softwareentwicklung verwendet, um die Kopplung zwischen verschiedenen Objekten zu verringern und den Code wieder verwenden zu können. Stell dir vor, du hast ein Programm, das einen Timer hat. Du möchtest, dass das Programm etwas tut, wenn der Timer abgelaufen ist. Statt den Code für das, was passieren soll, direkt in den Timer zu schreiben, könntest du das Delegate Design Pattern verwenden. Du könntest ein anderes Objekt als Delegat festlegen und es verantwortlich machen, was passieren soll, wenn der Timer abgelaufen ist. Auf diese Weise wäre der Timer unabhängig von dem, was passiert, wenn er abgelaufen ist, und der Code für das, was passieren soll, könnte an anderer Stelle im Programm geschrieben werden.

In Swift werden Delegates an vielen Stellen verwendet. Ein Beispiel sind Texteingabefelder (TextViews). Bevor ein Programm geschrieben ist weiß man nicht wie es auf Texteingaben des Benutzer reagieren soll. Deshalb können TextViews diese Aufgabe delegieren. Der Programmierer kann dann später selbst entscheiden wie sein Programm auf aktuelle Texteingaben reagiert.

Das Textfeld - der Delegierende gibt dafür dem Delegat bescheid wenn etwas passiert (z.b. der User die Eingabe beendet) und der Delegat kann dann reagieren (z.B. die Tastatur schließen)

Delegate und Protocol

Aber wie kann man dieses Pattern nun realisieren, und wie kann man ein Objekt zum Delegat machen?

Um dies zu realisieren werden Protocols verwendet.

1. Definiere ein delegate Protocol mit den Funktionen, die die ausführenden Delegaten untstützen sollen.
   1. protocol MyDelegateProtocol{ func myTask() }
2. Definiere eine Klasse die eine Variable vom Typ des Protokolls enthält. Über diese kann sie später den aktuellen Delegaten ansprechen.
   1. MyDelegatorClass{ var delegate: MyDelegateProtocol? //... }
3. Definiere in der Klasse ein oder mehrer Funktionen, die den Delegat anweisen etwas aus dem Protocol auszuführen
   1. func heyDelegateDoSomething(){delegate?.myTask}
4. Mache beliebige Klassen/Structs zu Delegaten indem du
   1. Das Protokoll implementierst
      1. class myClass: MyDelegateProtocol
   2. Die Funktionen aus dem Protocol implementierst
      1. func myTask(){//...}
   3. Das Delegat annimmst (z.B. in der init Funktion)
      1. init(delegationHandler: MyDelegatorClass) { delegationHandler.delegate = self }

Beispiel für die Implementierung eines vollständigen Delegate Pattern

/**
 Protocol says: who wants to do ADL must know hot to perform CPR (Wiederbelebung)
 */
protocol AdvancedLifeSupport{
    func performCPR()
}

/**
 If a emergency call comes in the EmergencyCallHandler is responsible to assess the situation an inform the delegate
 */
class EmergencyCallHandler {
    
    var delegate: AdvancedLifeSupport? // my delegate should have a ADL cdertificate
    
    func assessSituation() {
        print("Can you tell me what happended?")
    }

    func triggerMedicalEmergency() {
        delegate?.performCPR() // call the delegate (? if available) and tell him to perform CPR 
    }
}

/**
 When the paramedic goes on shift and picks up the emergency pager (meaning he sets the delegate to himself)
 */
struct Paramedic: AdvancedLifeSupport{
    
    init(handler: EmergencyCallHandler) {
        handler.delegate = self
    }
    
    func performCPR() {
        print("The paramedic does chest compressions 30 per second.")
    }
}

class Doctor: AdvancedLifeSupport{
    
    init(handler: EmergencyCallHandler){
        handler.delegate = self
    }
    func performCPR() {
        print("The doctor does chest compressions 30 per second.")
    }
    func useStethoscope(){
        print("Doctor listening for heart sounds.")
    }
}

class Surgeon: Doctor{
    override func performCPR() {
        super.performCPR()
        print("Singing Staying alive by the BeeGees")
    }
    func useElectricDrill(){
        print("Whirr...")
    }
}


let emma = EmergencyCallHandler()
let pete = Paramedic(handler: emma)
let angela = Surgeon(handler: emma)
/**
 note that pete will not get informed because the dalegate property (the pager) has changed to angela
 if you uncomment angela pete will do CPR
 */

emma.assessSituation()
emma.triggerMedicalEmergency() // CALL THE DELEGATE

Im Beispiel mit den Textfields gibt es also ein Protocol, welches vorgibt welche Funktionalität ein Delegat erfüllen muss. Sobald unsere Klasse das Delegat erhält müssen wir die zum Protokoll zugehörigen Funktionen implementieren.

class myClass{
  /...
  let textField = UITextField
  textField.delegate = self // now textFieldDidBeginEditing() is delegated to self
  //...