Ciò che il Principio di Inversione di dipendenza implica in pratica è che in un sistema, i componenti di alto livello dovrebbero dipendere dalle astrazioni dei componenti di basso livello (invece che dai componenti di basso livello direttamente), e le componenti di basso livello dovrebbero essere definite in termini di queste astrazioni.
Il punto chiave della mia domanda è che i componenti di basso livello sono definiti in termini di astrazioni, che sono definite in termini di componenti di alto livello . Significato: le componenti di alto livello 'definiscono l'astrazione' in termini di ciò che sarebbe conveniente per loro, e le componenti di basso livello devono essere definite secondo quell'astrazione (di solito un'interfaccia).
Quindi se il componente di alto livello è un Car
, e il componente di basso livello è Engine
, e viene definita un'interfaccia IEngine
- sarà definita in base alle esigenze del Car
, e Engine
dovrà soddisfare queste esigenze. Quindi, se è conveniente che Car
sia in grado di avviare semplicemente il motore, IEngine
conterrà un metodo start()
e Engine
dovrebbe implementarlo.
La mia domanda è:
Quando si inizia la programmazione su un progetto progettato secondo il principio di inversione delle dipendenze - sono i componenti di alto livello solitamente implementati prima di quelli di basso livello, vale a dire. Sviluppo "dall'alto verso il basso"?
Poiché il principio implica che i componenti di basso livello siano progettati in base a ciò che è conveniente per i componenti di alto livello, è logico iniziare prima a programmare i componenti di alto livello e solo successivamente definire l'interfaccia ILowLevelComponent
, in base a quale abbiamo imparato che i componenti di alto livello hanno bisogno di quando li abbiamo programmati.
Ad esempio stiamo implementando un sistema che simula un'auto. Car
è il componente di alto livello, mentre Engine
e SteeringWheel
sono i componenti di basso livello. Engine
e SteeringWheel
si prendono cura del lavoro concreto di spostamento della macchina, mentre Car
si occupa di coordinare tutto e creare un sistema funzionante.
Se stessimo progettando il sistema in base al DIP, ciò significa che Engine
e SteeringWheel
sono definiti in termini di un'astrazione, che è definita in termini di ciò che è conveniente per Car
.
Quindi sarebbe logico implementare prima Car
, capire esattamente come funzionerà in termini di alto livello e cosa deve funzionare, e solo allora definire le interfacce IEngine
e ISteeringWheel
, secondo quanto il Car
ha bisogno. E poi naturalmente implementare le classi concrete che implementano le interfacce.
Quindi quello che sto chiedendo è: quando si lavora su un progetto progettato nello spirito di DIP, l'approccio "dall'alto verso il basso" è comune? È così che di solito il lavoro viene svolto sul progetto seguendo il principio di inversione della dipendenza?