Patrón de diseño: Inyección de dependencias

La Inyección de dependencias es un concepto muy sencillo: si tienes un objeto que interactúa con otros objetos, la responsabilidad de encontrar una referencia a estos objetos en tiempo de ejecución se saca fuera del objeto en si mismo.

¿Qué significa para un objeto “interactuar” con otros objetos? Generalmente significa invocar métodos o leer atributos de estos objetos. Así si tenemos una clase A que invoca el método Calculate de la clase B, podemos decir que A interactúa con B.

En el siguiente ejemplo se muestra una clase A interactuando con una clase B. También podemos decir que A depende de la clase B para llevar a cabo una responsabilidad. En este caso, no solo se invoca al método Calculate pero también se crea una nueva instancia de la clase.

class A {
    private B _b;
    public A {
      _b = new B();
    }
    public int SomeMethod() {
      return (_b.Calculate() * 2);
    }
}

En el siguiente ejemplo, la responsabilidad de hacer una referencia a una implementación de una clase de tipo B se mueve fuera de A.

class A {
    private B _b;
    public A(B _b) {
        _b= b;
    }
    public int SomeMethod() {
        return _(b.Calculate * 2);
    }
}

En este caso se dice que una dependencia (B) ha sido inyectada dentro de A, mediante el constructor. Por supuesto, también se pueden inyectar dependencias a través de un atributo (o incluso en un método), como en el ejemplo siguiente:

class A {
private B _b;

public B B {
get { return _b; }
set { _b = value; }
}

public int SomeMethod(){
if (_b != null)
return _b.RetrieveValue() * 2;}
else
// HANDLE THIS ERROR CASE
return -1;
}
}

Esto es todo lo que hay sobre la inyección de dependencia. Todo lo demás se basa en este concepto básico.

 

Fuente: http://codecriticon.com/dependencia-inyeccion-dummies/