Capacítate con nosotros. Ir a KODOTI
Capacítate con nosotros. KODOTI

Ejemplo de inyección de dependencias con C#

Explicaremos como funciona este patrón que es usado bastante en muchos frameworks actuales como ASP.NET MVC, Angular, Laravel, entre otros.

Rodríguez Patiño, Eduardo
34,270 lecturas
Rodríguez Patiño, Eduardo
Hemos migrado nuestras publicaciones del blog antiguo. Si crees que esta se encuentra incompleta o sin coherencia deja un comentario para darle una pronta solución.

Si han llegado a esta página, es porque has oído hablar de dicho patrón y no lo logras entender. Pues si, los patrones son un poco confunsos de entender y peor aún en ¿que momento de la vida debemos usarlo?.

¿Que es inyección de dependencias?

Basicamente es quitarle la responsabilidad a nuestra clase principal de crear instancias a sus dependencias. En pocas palabras, en vez de que nuestra clase haga una instancia internamente a otra clase que depende, mejor le pasamos la clase que va a implementar como un parámetro adicional, de esta manera evitamos la dependencia directa. ¿Se entendió?, bueno ... espero que con el ejemplo se entienda mejor.

h3>Nuestro ejemplo

En nuestro ejemplo vamos a suministrar a un soldado que arma debería usar en el combate. Para ello, hemos creado las siguientes clases:

Las armas convertidas a Clase

public class Revolver
{
    public string Disparar()
    {
        return "Pum Pum ..";
    }
}

public class Rifle
{
    public string Disparar()
    {
        return "Pum pum pum pum pum ..";
    }
}

public class Escopeta
{
    public string Disparar()
    {
        return "pum PUMMM !! ..";
    }
}

Como se darán cuenta, las armas implementan el método Disparar(), la cual el disparo varía dependiendo del tipo de arma que se elija.

Nuestra clase Soldado

Esta clase implementa los métodos necesarios para realizar los disparos para cada arma.

public class Soldado
{
    public string DispararRevolver()
    {
        return new Revolver().Disparar();
    }

    public string DispararRifle()
    {
        return new Rifle().Disparar();
    }

    public string DispararEscopeta()
    {
        return new Escopeta().Disparar();
    }
}
  • ¿Cual es el problema?, que la dependencia la tiene que implementar el mismo Soldado.
  • ¿Y eso en que nos afecta?
    • Vamos a tener que modificar nuestra clase Soldado en un futuro si queremos agregar más armas, ahora esta simple porque solo hay 3 armas y cada una tiene un método. ¿Pero si fuerán 200 armas y cada una tiene 100 métodos?.
    • Realizar una prueba unitaria sería bastante tedioso, hay que probar método por método.
    • La clase a futuro va a ser un dolor de cabeza, teniendo un código que no permita su mantenimiento/mejora a futuro.
    • Al momento de instanciar la clase, vamos a tener que llamar a c/u de los métodos para manipular el arma seleccionada. Eso nos daría un serio problema, porque tendríamos que modificar el código constantemente si es que quisieramos cambiar de arma o hacer un uso excesivo y vulgar de los IF o SWITCH para saber con que arma se debe trabajar.

¿Cual es la solución?

Implementar una interface y que el constructor de la clase Soldado la reciba como parámetro.

Paso #1

Crear la interface y hacer que las armas implementen dicha interface.

public interface IArma {
    string Disparar();
}

public class Revolver : IArma
{
    public string Disparar()
    {
        return "Pum Pum ..";
    }
}

public class Rifle : IArma
{
    public string Disparar()
    {
        return "Pum pum pum pum pum ..";
    }
}

public class Escopeta : IArma
{
    public string Disparar()
    {
        return "pum PUMMM !! ..";
    }
}

Paso #2

Modificar nuestra clase Soldado para que reciba dicha interface.

public class Soldado
{
    protected IArma arma;

    public Soldado(IArma _arma)
    {
    this.arma = _arma;
    }

    public string Disparar()
    {
        return this.arma.Disparar();
    }
}

Si se dan cuenta ahora, solo tenemos un método "Disparar". Nuestra clase Soldado sabe que debe disparar un Arma, es nuestro constructor el encargado de setear que arma debe usar.

Veamos como se instancia nuestra clase Soldado usando como arma principal el Revolver:

var soldado = new Soldado(new Revolver());
soldado.Disparar();

Si queremos usar la escopeta:

var soldado = new Soldado(new Escopeta());
soldado.Disparar();

¿Y el rifle?

var soldado = new Soldado(new Rifle());
soldado.Disparar();

¿Se dieron cuenta lo lindo que ha quedado nuestro código?. Al final lo que hemos hecho es eliminar la dependenia de una clase dentro de otra clase.

NOTA: Me imagino que si has comprendido el ejemplo, tu mente ahora procesa varios casos para la cual usaría la inyección de dependencia. Sino fuera así, deja un comentario y te puedo orientar.


Estudia con nosotros

🚀 Mejora tus oportunidades laborales


¿Te gustó nuestra publicación?
Suscríbete a nuestro boletín