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. Konvention: Definiere das Protocol im File der delegierenden Klasse (siehe Schritt 2)
   2. protocol MyDelegateProtocol{ func myTask() }
2. Definiere eine Klasse die delegieren soll
   1. Sie hat eine Variable vom Typ des Protokolls. Über diese kann sie später den aktuellen Delegaten ansprechen.
      1. MyDelegatorClass{ var delegate: MyDelegateProtocol? //... }
   2. Füge Funktionen ein, die den späteren Delegat anweisen etwas aus dem Protocol auszuführen
      1. func heyDelegateDoSomething(){delegate?.myTask}
3. Mache beliebige Objekte zu Delegaten indem du
   1. Das Protocol implementierst
      1. class myClass: MyDelegateProtocol
   2. Die Funktionen aus dem Protocol implementierst
      1. func myTask(){//...}
   3. Das Delegat aufnimmst (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
  //...

Delegate Step by Step

Steps to be done in the SENDER side

step1:

create a protocol with method name in sender side

syntax:

    protocol ProtocolName{
    func functionName(parameters:Type)
    }

eg:

    protocol WeatherManagerDelegate{
     
    func didUpdateWeather(weather:WeatherModel)
     
    }

Step2:

create a delegate which adopts the protocol in the sender side

syntax:

var delegate:ProtocolName?

eg:

    var delegate:WeatherManagerDelegate?

step3:

send the data via delegate by calling the method Name mentioned the protocol in the sender side

syntax:

delegate.MethodNameInProtocol(parameterName:args)

eg:

delegate.didUpdateWeather(weather:weather)

Steps to be done in RECIEVER side

step1:

Implement the protocol in the viewController in the receiver end

syntax:

class ViewControllerName : protocolName

eg:

class  WeatherViewController:WeatherManagerDelegate

step 2:

Now enable receiving access in the receiver by creating an object

syntax:

var RecieverObjectName = SenderClassName()

eg:

var  weatherManager= WeatherManager()

step3:

Now allow the delegate to report data to the receiver

syntax:

RecieverObjectName.delegate=self

eg

weatherManager.delegate = self

step 4:

Now access the methods mentioned in the protocol

syntax:

    func functionName(parameterName: DataType) {
    print(weather)
    }

eg :

     func didUpdateWeather(weather: WeatherModel) {
            print(weather)
         }