Inversion of Control e dintorni: Dependency Injection – parte 3 di 3

Nel post precente ho introdotto il pattern Dependency Injection, facente parte della famiglia di pattern IoC: qui discuterò, invece, del pattern Service Locator.

Proseguendo con l’esempio esposto nelle precedenti puntate il problema da risolvere è che la classe DirectoryController, presentata nei post precedenti, non rispetta il principio Dependency Inversion Principle. Infatti dipende pesantemente dalla classe utilizzata per il logging.

Abbiamo già dato una prima soluzione, ma in questa parte daremo una versione alternativa.

In questa caso invece di passare la classe da usare per il logging nel costruttore, o in un metodo o proprietà, (vedi Dependency Injection) ci si affida a uno “store centrale”, che memorizza tutte le associazioni interfaccia-istanza dell’oggetto da utilizzarsi.

Quindi usando questo store è possibile prelevare l’instanza della classe logger di interesse.

Più facile a vedersi con un esempio che a descrivere.

Continue reading

Inversion of Control e dintorni: Dependency Injection – parte 2 di 3

Nel post precente ho introdotto cosa si intende per SOLID e cosa ci “azzecca” IoC.

In estrema sintesi la regola D relativa a SOLID (DIP = Dependency Inversion Principle) può essere rispettata usando il pattern Ioc Inversion Of Control, in una delle sue due varianti: Dependency Inversion o Service Locator.

Il questo post verrà descritta la prima variante (Dependency Injection) che ritengo essere il metodo più semplice per implementare il pattern IoC e quindi risolvere il principio Dependency Inversion Principle (DIP).

Ricordo questo principio (esemplificando) afferma che non dovrebbero esistere due pezzi di codice che dipendono direttamente l’uno dall’altro.

Nel nostro esempio abbiamo la classe DirectoryController che dipende pesantemente dalla classe LogWriter e dalla classe LogWriterOnEventViewer.

In definitiva ecco l’implementazione.

Continue reading

Inversion of Control e dintorni: Dependency Injection – parte 1 di 3

Qualche tempo fa stavo mettendo mano al codice scritto da un altro collega programmatore e, dopo aver verificato che il tutto era scritto sicuramente in modo molto originale ed efficace, ho anche notato che il risultato non rispettava, nemmeno da lontano, alcun principio SOLID.

In particolare il principio Dependency Inversion Principle (per gli amici DIP) che permette, tra l’altro, di scrivere unit test in modo veloce, era stato “bellamente” ignorato.

Dopo aver discusso con l’autore mi sono reso conto che il problema era che lui non aveva la minima conoscenza di questo argomento, pur essendo un ottimo programmatore. Per questo motivo ho pensato di scrivere queste poche righe, nella speranza che possano essere utili anche ad altri.

Continue reading