Puoi spiegare le differenze tra i concetti di Dependency Injection e Dependency Inversion nel contesto dello sviluppo software?

Dependency Injection (DI) — è un pattern di progettazione in cui le dipendenze di un oggetto vengono passate dall'esterno, anziché essere create internamente. Questo permette di cambiare facilmente le implementazioni delle dipendenze, semplifica i test e aumenta la modularità del codice.

Principio di Inversione delle Dipendenze (DIP) — uno dei cinque principi SOLID, che afferma che:

• I moduli di alto livello non devono dipendere da moduli di basso livello. Entrambi devono dipendere da astrazioni.
• Le astrazioni non devono dipendere dai dettagli. I dettagli devono dipendere dalle astrazioni.

In parole semplici, DIP mira a ridurre l'accoppiamento tra i componenti attraverso l'uso di astrazioni (ad esempio, interfacce).

Relazione tra loro: DI è un modo per implementare DIP. Usando DI, passiamo le dipendenze tramite il costruttore o i setter, permettendo ai moduli di dipendere da astrazioni piuttosto che da implementazioni concrete.

Esempio in Swift:

protocol NetworkService {
    func fetchData()
}

class APIService: NetworkService {
    func fetchData() {
        print("Recupero dati dall'API")
    }
}

class ViewModel {
    private let networkService: NetworkService

    // Dependency Injection tramite il costruttore
    init(networkService: NetworkService) {
        self.networkService = networkService
    }

    func load() {
        networkService.fetchData()
    }
}

let apiService = APIService()
let viewModel = ViewModel(networkService: apiService)
viewModel.load()

Qui, ViewModel dipende dall'astrazione NetworkService (DIP), e l'implementazione concreta viene passata dall'esterno (DI).