Protokoldeki isteğe bağlı fonksiyonu ne bozar?

Başka modüller veya kitaplıklar kullanmaya başladıktan sonra protokol gereksinimlerini eklemek. Eğer protokol zaten kabul edilmiş ve uygulanmışsa, opsiyonel (zorunlu olmayan) metodlar veya özellikler eklemek, bu protokolün kullanıldığı tüm yerlerde derleme hatalarına yol açar, bu yeni gereksinimler yerine getirilene kadar.

Opsiyonel gereksinimler, mevcut uygulamaları "kırmadan" protokolleri genişletmeye olanak tanır. Sınıflar veya yapılar yalnızca opsiyonel metodların bir kısmını uygulayabilir. Bu, delegelerle çalışırken veya zaten kurulu bir API'ye yeni fonksiyonlar eklerken faydalıdır.

Objective-C'deki protokolde opsiyonel gereksinim örneği (Swift @optional'ı @objc olmadan desteklemediği için):

// Swift'te, `@optional` `@objc protocol` ile kullanılır
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 {
            // Opsiyonel metoda çağrı ve kontrol
            delegate?.optionalMethod1?()

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

Swift'te saf protokoller (@objc olmadan) @optional desteklemez. Opsiyonel gereksinimler için, protokol @objc ile işaretlenmelidir. Bu protokollerin uygulamaları, varsayılan opsiyonel metod uygulamaları eklemek için genişletmeler kullanabilir, bu da Swift'te daha modern bir yaklaşımdır.

Swift'te protokol genişletmeleriyle opsiyonel davranış örneği:

// Daha Swift-uyumlu yaklaşım: varsayılan uygulamalar içeren protokol genişletmeleri
protocol MyProtocol {
    func requiredMethod() -> Bool
    func optionalMethod1()
    func optionalMethod2(value: Int)
}

// Opsiyonel metodlar için varsayılan uygulamalar sağlıyoruz
extension MyProtocol {
    func optionalMethod1() {
        // Varsayılan boş uygulama veya standart davranış
        print("Varsayılan opsiyonel metod 1 uygulaması")
    }

    func optionalMethod2(value: Int) {
        // Varsayılan boş uygulama
        print("Opsiyonel metod 2 varsayılan uygulaması, değer: \(value)")
    }
}

class MyClassSwift {
    var delegate: MyProtocol?

    func doSomething() {
        if delegate?.requiredMethod() == true {
            // Nil kontrolü olmadan metodları çağırıyoruz, çünkü
            // ya sınıf/struct'ta uygulanmışlar ya da
            // genişletmeden gelen uygulama kullanılıyor
            delegate?.optionalMethod1()
            delegate?.optionalMethod2(value: 20)
        }
    }
}

class MyCustomDelegate: MyProtocol {
    func requiredMethod() -> Bool {
        print("Gerekli metod uygulandı")
        return true
    }

    // optionalMethod1() ve optionalMethod2(value:) uygulamak zorunda değil,
    // genişletmeden gelen varsayılan uygulama kullanılacak.
    // Ama başka davranış istenirse üzerine yazılabilir:
    // func optionalMethod1() {
    //     print("Opsiyonel metodun özel uygulaması")
    // }
}

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

Bu şekilde, protokolde opsiyonel bir fonksiyon eklemek, zaten kullanılan bir protokole yeni zorunlu gereksinimler eklemeye çalışırken geri uyumluluğu bozar. Opsiyonel gereksinimlerin kullanımı (@objc veya tercihen protokol genişletmeleri aracılığıyla) bu sorunu önler.