Anexsoft | Blog y dictado de cursos de Tecnología

En este encontrarás tutoriales de tecnología como PHP, ASP.NET MVC, Front-End, entre otros y cursos exigentes de modalidad online que te ayudarán a crecer profesionalmente.

Queremos mejorar la calidad de nuestros cursos. Por favor ayúdanos llenando esta pequeña encuesta
Ejemplo de inyección de dependencias con C#
Actualizado el 21 Enero, 2016 y leído 23,410 veces
Calificación: 9.74 / 10

Ejemplo de inyección de dependencias con C#

Anexsoft

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.

 

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.

¡Adquiera ya!

  • Código de fuente de Red Social desarrollada en ASP.NET MVC

    Código de fuente de Red Social desarrollada en ASP.NET MVC
  • Software de Venta e Inventario hecho en PHP y Codeigniter

    Software de Venta e Inventario hecho en PHP y Codeigniter
  • Software de Portafolio Profesional hecho en ASP.NET MVC 5 C#

    Software de Portafolio Profesional hecho en ASP.NET MVC 5 C#

Últimas publicaciones

Encuesta

¿Sobre qué te gustaría que se hable más?

Síguenos

Estudia con nosotros y crece profesionalmente

Nuestros cursos han sido hecho en base a lo que demanda el mercado hoy en día.
La experiencia obtenida es la de un ambiente laboral.

Anexsoft
© 2018 Anexsoft, blog y cursos online de TI.