Was verletzt die optionale Funktion im Protokoll?

Hinzufügen von Anforderungen an das Protokoll, nachdem es bereits von anderen Modulen oder Bibliotheken verwendet wird. Wenn das Protokoll bereits angenommen und implementiert wurde, führt das Hinzufügen von optionalen (nicht verpflichtenden) Methoden oder Eigenschaften zu Kompilierungsfehlern an allen Stellen, an denen das Protokoll verwendet wird, bis diese neuen Anforderungen erfüllt sind.

Optionale Anforderungen ermöglichen es, Protokolle zu erweitern, ohne bestehende Implementierungen "kaputt" zu machen. Klassen oder Strukturen können nur einen Teil der optionalen Methoden implementieren. Dies ist nützlich bei der Arbeit mit Delegierten oder beim Hinzufügen neuer Funktionen zu einer bereits etablierten API.

Beispiel für eine optionale Anforderung in einem Objective-C-Protokoll (da Swift @optional ohne @objc nicht unterstützt):

// In Swift wird `@optional` mit `@objc protocol` verwendet
import Foundation

@objc protocol MyDelegate {
    func requiredMethod() -> Bool

    @optional func optionalMethod1()
    @optional func optionalMethod2(value: Int)
}

class MyClass {
    weak var delegate: MyDelegate?

    func doSomething() {
        if delegate?.requiredMethod() == true {
            // Aufruf einer optionalen Methode mit Prüfung
            delegate?.optionalMethod1?()

            if let delegate = delegate {
                if delegate.responds(to: #selector(delegate.optionalMethod2(value:))) {
                    delegate.optionalMethod2?(value: 10)
                }
            }
        }
    }
}

In Swift unterstützen reine Protokolle (ohne @objc) @optional nicht. Damit es optionale Anforderungen gibt, muss das Protokoll mit @objc gekennzeichnet sein. Implementierungen solcher Protokolle können Erweiterungen verwenden, um Standardimplementierungen für optionale Methoden hinzuzufügen, was einen moderneren Ansatz in Swift darstellt.

Beispiel für optionales Verhalten durch Protokollerweiterungen in Swift:

// Ein moderner Swift-Ansatz: Protokollerweiterungen mit Standardimplementierungen
protocol MyProtocol {
    func requiredMethod() -> Bool
    func optionalMethod1()
    func optionalMethod2(value: Int)
}

// Standardimplementierungen für "optionale" Methoden bereitstellen
extension MyProtocol {
    func optionalMethod1() {
        // Standardleere Implementierung oder Standardverhalten
        print("Standardimplementierung von optionalMethod1")
    }

    func optionalMethod2(value: Int) {
        // Standardleere Implementierung
        print("Standardimplementierung von optionalMethod2 mit Wert: \(value)")
    }
}

class MyClassSwift {
    var delegate: MyProtocol?

    func doSomething() {
        if delegate?.requiredMethod() == true {
            // Methoden ohne Nil-Check aufrufen, da sie entweder in der Klasse/Struktur implementiert sind oder
            // die Standardimplementierung aus der Erweiterung verwenden
            delegate?.optionalMethod1()
            delegate?.optionalMethod2(value: 20)
        }
    }
}

class MyCustomDelegate: MyProtocol {
    func requiredMethod() -> Bool {
        print("Erforderliche Methode implementiert")
        return true
    }

    // optionalMethod1() und optionalMethod2(value:) sind nicht verpflichtend zu implementieren,
    // die Standardimplementierung aus der Erweiterung wird verwendet.
    // Sie können sie jedoch überschreiben, wenn ein anderes Verhalten gewünscht ist:
    // func optionalMethod1() {
    //     print("Benutzerdefinierte Implementierung von optionalMethod1")
    // }
}

let customDelegate = MyCustomDelegate()
let myClassSwift = MyClassSwift()
myClassSwift.delegate = customDelegate
myClassSwift.doSomething()

Daher verletzt das Hinzufügen einer optionalen Funktion in einem Protokoll die Rückwärtskompatibilität, wenn versucht wird, eine neue verpflichtende Anforderung zu einem bereits verwendeten Protokoll hinzuzufügen. Die Verwendung optionaler Anforderungen (über @objc oder vorzugsweise durch Protokollerweiterungen) verhindert diese Verletzung.