Dependency Injection

Este es uno de los patrones de diseño de software de mayor popularidad al momento.
Por qué?
Favorece la implementación de clases que no son cohesivas, privilegia el código reusable, y libera a nuestro software del paradigma de las dependencias que muchas veces le impiden evolucionar. Por medio de este, podemos crear piezas de código para usar en nuestro software, y cuya arquitectura une los componentes, en vez de que los componentes se liguen a sí mismos.
En este patrón, que es una de las formas de Inversión del control, se emplea un objeto Factory, donde se crean las instancias de las clases y ahí mismo se relacionan.
Antes de usarlo en nuestro sitio MVC, es necesario que lo comprendamos a fondo, aun que dicen por ahí que para implementar un patrón no es necesario comprenderlo…así como lo leen!. Se supone que al ser algo que ya ha sido probado y cuya estructura está definida, no requiere de mucho seso, basta con que funcione. Desde luego no es mi filosofía, creo que debemos estar muy consientes de lo que hacemos, aun mas, si es que funciona. No creen?
He visto innumerables ejemplos, todos ellos muy interesantes, pero que no son aptos para “menores” (léase programadores principiantes o inexpertos), sin embargo al estar investigando algún Framework para implementar este patrón, me encontré el Ninject, y al revisar su documentación pude ver un ejemplo que presentan para ejemplificar la implementación a mano (sin su framework) que me dejo muy impresionado, por lo simple y didáctico, así que no pude resistirme a usarlo (basándome en el suyo) en un post para ejemplificarlo antes de hablar de cómo implementarlo con el patrón de repositorio.
Ejemplo:
Imaginemos lo siguiente: Estamos creando un juego de Guerreros del oriente, por lo que necesitamos crear armas para que los guerreros puedan emplear en contra de sus enemigos, y necesitamos Guerreros que peleen en el juego.
Primero tratemos de solucionar el problema de la forma tradicional:
Código de la Espada
class Espada {
public void Accion(string objetivo) {
Console.WriteLine("{0} fue limpiamente cortado por la mitad", objetivo);
}
}
Código del Guerrero:
class Samurai {
private Espada _espada;
public Samurai() {
_espada = new Espada();
}
public void Ataque(string objetivo) {
_espada.accion(objetivo);
}
}
Código de la consola de pruebas:
class Program {
public static void Main() {
Samurai warrior = new Samurai();
warrior.Ataque("El ninja");
}
}
Analicemos el código: A pesar que la espada es una clase diferentes, esta se instancia dentro de la clase samurái, por lo que las hace cohesivas, o sea Samurái depende de la clase Espada. Si después tuviéramos una clase Katana y quisiéramos que el samurái la usara, sería necesario cambiar el código.
DI al rescate
Como hemos comentado en algún otro post, lo primero es hacer una interface, para que las armas que creemos se deriven del mismo tipo, y de esta forma podamos hacer el cambio que se requiere, sin tener que modificar el código.

Una vez hecho esto podemos crear instancias de armas que implementen esta interface:

Bien, en este momento vamos a crear los guerreros; como en el caso del arma, vamos a partir de una Interface Guerrero:

Creamos los guerreros:

Codifiquemos la batalla:

Al ejecutarlo podremos ver:

Espero que el ejemplo sea muy ilustrativo…al menos fue divertido codificarlo .