Cum poate utilizarea pattern-ului Singleton să încalce principiile polimorfismului?

Singleton limitează crearea instanțelor unei clase la un singur obiect. Polimorfismul, însă, implică posibilitatea de a lucra cu obiecte din diferite clase printr-o interfață comună sau o clasă de bază.

Încălcarea apare atunci când codul client este rigid legat de o anumită clasă Singleton, în loc să lucreze cu o abstracție (protocol sau clasă de bază). În acest caz, nu este posibil să înlocuiți cu un alt obiect alternativ care implementează aceeași funcționalitate, deoarece clientul așteaptă exact o instanță Singleton.

// Utilizare greșită - clientul depinde direct de ConcreteSingleton
class ConcreteSingleton {
    static let shared = ConcreteSingleton()
    private init() {}

    func performAction() {
        print("Executarea acțiunii din ConcreteSingleton")
    }
}

// Client
func clientFunction() {
    // Legare rigidă la ConcreteSingleton
    ConcreteSingleton.shared.performAction()
}

// Utilizare corectă - clientul depinde de un protocol
protocol Service {
    func performAction()
}

class RealService: Service {
    func performAction() {
        print("Executarea acțiunii din RealService")
    }
}

class MockService: Service {
    func performAction() {
        print("Executarea acțiunii din MockService")
    }
}

// Singleton pentru furnizarea implementării prin protocol (opțional, se poate folosi DI)
class ServiceProvider {
    static let shared = ServiceProvider()
    private init() {}

    private var currentService: Service = RealService()

    func setService(_ service: Service) {
        currentService = service
    }

    func getService() -> Service {
        return currentService
    }
}

// Client
func flexibleClientFunction() {
    // Lucru prin abstracție (protocol)
    let service = ServiceProvider.shared.getService()
    service.performAction()
}

// Exemple de polimorfism cu client flexibil
// ServiceProvider.shared.setService(MockService())
// flexibleClientFunction() va folosi MockService

Astfel, utilizarea directă a proprietății statice shared a Singleton-ului în codul client reduce flexibilitatea și împiedică înlocuirea implementărilor, ceea ce reprezintă un aspect cheie al polimorfismului atunci când se lucrează cu diferite tipuri de obiecte printr-o interfață comună. Soluția este să lucrați cu instanța Singleton printr-un protocol sau o clasă de bază.