Inyección de dependecias C#
11
mayo
2020

Definición:

El concepto de inyección de dependencias se resume de una forma simple en:

Quitarle la responsabilidad a una clase principal de crear instancias a sus dependencias

https://www.udemy.com/course/master-programacion-netnet-core-c-con-visual-studio/learn/lecture/15749122#overview

Esto viene a decir, que la clase principal no tendrá creadas instancias de otras clases sino que en lugar de eso se le pasará como parámetro del constructor la referencia a la clase que queremos inyectar en nuestra clase principal.

Utilidad:

Evitar una dependencia directa.

Beneficios:

  • Evita el acomplamiento.
  • Aumenta la cohesión.
  • Facilita el mantenimiento.

Implementación:

Una película según su duración se puede clasificar en:

  • LargoMetraje > 60 min
  • MedioMetraje entre 30 min y 60 min
  • CortoMetraje < 30 min

Con esto podemos crear varias clases que implementen una interfaz IMetraje que nos ayude a realizar la inyección de dependencias.

    public interface IMetraje
    {
        string Reproducir();
    }
    public class LargoMetraje : IMetraje
    {
        public string Reproducir()
        {
            return "Reproduciendo una película de más de 60 minutos";
        }
    }
    public class MedioMetraje : IMetraje
    {
        public string Reproducir()
        {
            return "Reproduciendo una película de entre 30 y 60 minutos";
        }
    }

    public class CortoMetraje : IMetraje
    {
        public string Reproducir()
        {
            return "Reproduciendo una película que puede durar hasta 20 minutos";
        }
    }

Ahora que ya tenemos nuestro código para los metrajes, podemos hacer una clase película que use dichos metrajes:

    public class Pelicula
    {
        private IMetraje _metraje;

        public Pelicula(IMetraje metraje)
        {
            this._metraje = metraje;
        }

        public string Reproducir()
        {
            return _metraje.Reproducir();
        }
    }

Aquí es donde reside el truco de la inyección de dependencias, si os fijáis es muy simple. Para evitar que en nuestra clase Pelicula tengamos una instancia de cada una de las clases de tipo metraje para poder llamar a su método Reproducir() correspondiente, lo que hacemos es que dejamos declarada una variable de tipo IMetraje que nos permite poder usar el método Reproducir() de cada una de las clases que implemente la interfaz y por ello sólo tenemos un método Reproducir() en la clase Pelicula.

Uso del patrón:

class Program
    {
        static void Main(string[] args)
        {
            var largoMetraje = new LargoMetraje();
            var medioMetraje = new MedioMetraje();
            var cortoMetraje = new CortoMetraje();

            Pelicula peliculaLarga = new Pelicula(largoMetraje);
            Pelicula peliculaMedia = new Pelicula(medioMetraje);
            Pelicula peliculaCorta = new Pelicula(cortoMetraje);

            Console.WriteLine(peliculaLarga.Reproducir());
            Console.WriteLine(peliculaMedia.Reproducir());
            Console.WriteLine(peliculaCorta.Reproducir());
        }
    }

Utilizamos nuestro constructor para pasarle la instancia de cada tipo de película a Pelicula y así podemos usar nuestro método Reproducir().

Espero que os haya servido de ayuda

Referencias:

Vector de Fondo creado por macrovector – www.freepik.es

https://www.udemy.com/course/master-programacion-netnet-core-c-con-visual-studio/learn/lecture/15749122#overview

Comenta!

Loading Facebook Comments ...
Leave a Comment