Cosa viola la funzione opzionale nel protocollo?

Aggiunta di requisiti al protocollo dopo che altri moduli o librerie hanno iniziato a usarlo. Se il protocollo è già stato accettato e implementato, aggiungere metodi o proprietà opzionali (non obbligatori) causerà errori di compilazione in tutti i punti in cui il protocollo viene utilizzato, finché questi nuovi requisiti non saranno soddisfatti.

I requisiti opzionali consentono di estendere i protocolli senza "rompere" le implementazioni esistenti. Le classi o strutture possono implementare solo una parte dei metodi opzionali. Questo è utile quando si lavora con delegati o si aggiungono nuove funzioni a un'API già consolidata.

Esempio di requisito opzionale in un protocollo Objective-C (poiché Swift non supporta @optional senza @objc):

// In Swift, `@optional` si usa con `@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 {
            // Chiamata a metodo opzionale con verifica
            delegate?.optionalMethod1?()

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

In Swift, i protocolli puri (senza @objc) non supportano @optional. Per avere requisiti opzionali, il protocollo deve essere contrassegnato come @objc. Le implementazioni di tali protocolli possono usare estensioni per aggiungere implementazioni di default dei metodi opzionali, il che rappresenta un approccio più moderno in Swift.

Esempio di comportamento opzionale tramite estensioni di protocolli in Swift:

// Approccio più Swift: estensioni di protocolli con implementazioni di default
protocol MyProtocol {
    func requiredMethod() -> Bool
    func optionalMethod1()
    func optionalMethod2(value: Int)
}

// Forniamo implementazioni di default per i metodi "opzionali"
extension MyProtocol {
    func optionalMethod1() {
        // Implementazione di default vuota o comportamento standard
        print("Implementazione di default del metodo opzionale 1")
    }

    func optionalMethod2(value: Int) {
        // Implementazione di default vuota
        print("Implementazione di default del metodo opzionale 2 con valore: \(value)")
    }
}

class MyClassSwift {
    var delegate: MyProtocol?

    func doSomething() {
        if delegate?.requiredMethod() == true {
            // Chiamiamo i metodi senza controllo di nil, poiché
            // sono implementati nella classe/struttura o
            // usano l'implementazione dell'estensione
            delegate?.optionalMethod1()
            delegate?.optionalMethod2(value: 20)
        }
    }
}

class MyCustomDelegate: MyProtocol {
    func requiredMethod() -> Bool {
        print("Metodo richiesto implementato")
        return true
    }

    // optionalMethod1() e optionalMethod2(value:) non sono obbligatori da implementare,
    // verrà usata l'implementazione di default dall'estensione.
    // Ma si possono sovrascrivere se si desidera un comportamento diverso:
    // func optionalMethod1() {
    //     print("Implementazione personalizzata del metodo opzionale 1")
    // }
}

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

In questo modo, aggiungere una funzione opzionale in un protocollo viola la compatibilità retroattiva se si tenta di aggiungere un nuovo requisito obbligatorio a un protocollo già in uso nel codice esistente. L'uso di requisiti opzionali (tramite @objc o, preferibilmente, tramite estensioni di protocolli) previene questa violazione.