Wat schendt de optionele functie in het protocol?

Het toevoegen van vereisten aan het protocol nadat andere modules of bibliotheken het zijn gaan gebruiken. Als het protocol al is geaccepteerd en geïmplementeerd, zal het toevoegen van optionele (niet-verplichte) methoden of eigenschappen compileerfouten veroorzaken op alle plaatsen waar het protocol wordt gebruikt, totdat aan deze nieuwe vereisten wordt voldaan.

Optionele vereisten maken het mogelijk om protocollen uit te breiden zonder bestaande implementaties te "breken". Klassen of structuren kunnen slechts een deel van de optionele methoden implementeren. Dit is handig bij het werken met delegates of het toevoegen van nieuwe functies aan een al gevestigde API.

Voorbeeld van een optionele vereiste in een Objective-C protocol (omdat Swift @optional niet ondersteunt zonder @objc):

// In Swift wordt `@optional` gebruikt met `@objc protocol`
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 {
            // Aanroepen van een optionele methode met controle
            delegate?.optionalMethod1?()

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

In Swift ondersteunen pure protocollen (zonder @objc) @optional niet. Om optionele vereisten te hebben, moet het protocol worden gemarkeerd als @objc. Implementaties van dergelijke protocollen kunnen extensies gebruiken om standaardimplementaties voor optionele methoden toe te voegen, wat een meer moderne aanpak in Swift is.

Voorbeeld van optioneel gedrag via protocoluitbreidingen in Swift:

// Meer Swift-achtig: protocoluitbreidingen met standaardimplementaties
protocol MyProtocol {
    func requiredMethod() -> Bool
    func optionalMethod1()
    func optionalMethod2(value: Int)
}

// Bieden van standaardimplementaties voor "optionele" methoden
extension MyProtocol {
    func optionalMethod1() {
        // Standaardimplementatie of standaardgedrag
        print("Standaardimplementatie van optionele methode 1")
    }

    func optionalMethod2(value: Int) {
        // Standaardimplementatie
        print("Standaardimplementatie van optionele methode 2 met waarde: \(value)")
    }
}

class MyClassSwift {
    var delegate: MyProtocol?

    func doSomething() {
        if delegate?.requiredMethod() == true {
            // Methoden aanroepen zonder nil-controle, omdat ze
            // of geïmplementeerd zijn in de klasse/structuur, of
            // de standaardimplementatie uit de extensie gebruiken
            delegate?.optionalMethod1()
            delegate?.optionalMethod2(value: 20)
        }
    }
}

class MyCustomDelegate: MyProtocol {
    func requiredMethod() -> Bool {
        print("Vereiste methode geïmplementeerd")
        return true
    }

    // optionalMethod1() en optionalMethod2(value:) hoeven niet geïmplementeerd te worden,
    // de standaardimplementatie uit de extensie wordt gebruikt.
    // Maar ze kunnen worden overschreven als een ander gedrag gewenst is:
    // func optionalMethod1() {
    //     print("Aangepaste implementatie van optionele methode 1")
    // }
}

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

Op deze manier breekt het toevoegen van een optionele functie in een protocol de achterwaartse compatibiliteit wanneer je probeert een nieuwe verplichte vereiste toe te voegen aan een al in gebruik zijnd protocol. Het gebruik van optionele vereisten (via @objc of, bij voorkeur, via protocoluitbreidingen) voorkomt deze breuk.