Inyección de Dependencias con ASP.NET y MVC

¿Qué es la inyección de dependencias? La inyección de dependencias es un patrón de diseño de software usado en la Programación Orientada a Objetos. Trata de solucionar las necesidades de creación de los objetos de una manera práctica y útil. 

En este post y videotutorial explicaremos de manera detallada cómo realizar Inyección de dependencias. Asi que también aplicaremos Inversión de control con AutoFac en nuestro proyecto ASP.NET MVC.

También veremos como la clase Caballo.cs implementa una interfaz que declara los métodos para suministrar dependencia. Mientras que el inyector utiliza esta interfaz para proporcionar dependencia a la clase Caballo.cs.

Por que, el objetivo final de este proyecto será mostrar una lista de los caballos en un Club Hípico.

¡Empezamos!

Lo primero que haremos será crearnos nuestro proyecto MVC Vacio (empty) y marcaremos MVC, en esta ocasión usaremos EntityFramework, por tanto, debemos descargarnos los Nuget: AutoFac, AutoFac.Mvc5 y EntityFramework.

Por lo tanto, una vez tengamos los NuGet instalados crearemos en nuestra carpeta Model la clase Caballo.cs.

En ella añadiremos añadiremos las propiedades que tenemos en nuestra base de datos en la tabla Caballo.

Y a continuación mapearemos nuestras tablas, para más adelante poder mostrar esta información en nuestra Vista.

Vamos a entonces a mapear la tabla Caballo.cs

CABALLOS.CS

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
using System.Linq;
using System.Web;

namespace InyeccionDependenciasPrueba.Models
{
    [Table("Caballo")]
    public class Caballo
    {
        [Key]
        [DatabaseGenerated(DatabaseGeneratedOption.None)]
       
        [Column("Nombre")]
        public String Nombre { get; set; }
        [Column("Id_Nivel")]
        public int IdNivel { get; set; }
        [Column ("Id")]
        public int IdCaballo { get; set; }

        [Column("Ruta_Foto")]
        public String Foto { get; set; }
    }
}

El siguiente paso será ir a nuestro Web.Config donde añadiremos nuestra cadena de conexión dirigida a la bbdd con la que estamos trabajando.

WEB.CONFIG

CADENA DE CONEXION EN WEB.CONFIG  
<connectionStrings>
    <add name="cadenacaballos" connectionString="Data Source=prieto;Initial Catalog=Hipica;Integrated Security=True" providerName="System.Data.SqlClient" />
  </connectionStrings>

Una vez revisado nuestra cadena de conexión, nos crearemos nuestro Contexto. Será por tanto nuestro proveedor de datos por lo que creamos una clase en Models que llamaremos CaballosContext.

Así que lo primero que haremos aquí será heredar de la clase DbContext. Y haremos el using a EntityFramework.

Ahora creamos el constructor para que coja el name de la conexión, yo en este caso lo he llamado: cadenacaballos. (Estamos heredando el constructor de DbContext).

RECUERDA: DbContext es la clase que te permite el acceso a datos

CODIGO: CaballosContext.cs - DbContext

using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.Linq;
using System.Web;

namespace InyeccionDependenciasPrueba.Models
{
    public class CaballosContext : DbContext
    {
        public CaballosContext() : base("name=cadenacaballos") { }
        public DbSet<Caballo> Caballos { get; set; }

    }
}

Lo siguiente que haremos es crear un repositorio donde sacaremos los caballos de nuestra Hípica y nos devolverá la colección de caballos.

Por lo tanto para que un repositorio cumpla la función que queremos, nos crearemos nuestra clase Repositorio en una carpeta nueva llamada: Repositories.

Aquí dentro crearemos nuestra Interface y es dónde definiremos para que lo queremos, la declaración de los métodos. Es decir que métodos necesito que vayan en la aplicación.

A continuación, como en el repositorio Caballos lo que queremos es representar una lista de nuestros caballos, necesito un método que pueda devolver una colección de la clase Caballo, un método con una consulta para devolver esos caballos. En este caso lo haremos con el DbContext.

IRepositoryCaballos.cs

CODIGO: IRepositoryCaballos.cs

using InyeccionDependenciasPrueba.Models;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace InyeccionDependenciasPrueba.Repositories
{
    public interface IRepositoryCaballos
    {
        List<Caballo> GetCaballos();
    }
}

Ahora nos crearemos la clase RepositoryCaballos dentro de la carpeta Repositories. La función de esta clase será heredar de la clase IRepositoryCaballos para asegurar que va a implementar los métodos. Con esto, nos aseguramos 100% que el método se ha implementado.

RepositoryCaballos.cs

using InyeccionDependenciasPrueba.Models;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

namespace InyeccionDependenciasPrueba.Repositories
{
    public class RepositoryCaballos : IRepositoryCaballos
    {
    

        public List<Caballo> GetCaballos()
        {
		throw new NotImplementedException();
        }
    }
}

El siguiente paso será crearnos el constructor, y sacaremos los datos de SQL así que usaremos de nuevo CaballosContext:

CODIGO: RepositoryCaballos.cs

using InyeccionDependenciasPrueba.Models;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

namespace InyeccionDependenciasPrueba.Repositories
{
    public class RepositoryCaballos : IRepositoryCaballos
    {
        CaballosContext context;

        public RepositoryCaballos()
        {
            this.context = new CaballosContext();
        }
        public List<Caballo> GetCaballos()
        {
            throw new NotImplementedException();
        }
    }
}

Más tarde pasaremos el parámetro por RepositoryCaballos y devolvemos la lista Caballos mediante la siguiente consulta.

CODIGO: RepositoryCaballos.cs

using InyeccionDependenciasPrueba.Models;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

namespace InyeccionDependenciasPrueba.Repositories
{
    public class RepositoryCaballos : IRepositoryCaballos
    {
        CaballosContext context;

        public RepositoryCaballos()
        {
            this.context = new CaballosContext();
        }
    

        public List<Caballo> GetCaballos()
        {
            var consulta = from datos in context.Caballos
                           select datos;
            return consulta.ToList();
        }
    }

}

Una vez tengamos lo anterior correctamente, vamos a crearnos nuestro controlador: Lo llamaremos CaballosController, para que funcione necesitamos el repositorio.

CaballosController.cs

CODIGO: CaballosController.cs

using InyecciónDependenciasHipica.Repositories;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;

namespace InyecciónDependenciasHipica.Controllers
{
    public class CaballosController : Controller
    {
        RepositoryCaballo repo;

        public CaballosController()
        {
            this.repo = new RepositoryCaballo();
        }

        // GET: Caballos
        public ActionResult Index()
        {
            return View(this.repo.GetCaballos());
        }
    }
}

En el ActionResult devolvemos los Caballos y ya podemos crear la vista.

Usaremos scaffolding para que nos muestre los datos mediante una lista.

Index.cshtml

CODIGO: Index.cshtml

@model IEnumerable<InyecciónDependenciasHipica.Models.Caballo>

@{
    ViewBag.Title = "Index";
}

<h2>Index</h2>

<p>
    @Html.ActionLink("Create New", "Create")
</p>
<table class="table table-striped">
    <tr>
        <th>
            @Html.DisplayNameFor(model => model.IdNivel)
        </th>
        <th>
            @Html.DisplayNameFor(model => model.IdCaballo)
        </th>
        <th>
            @Html.DisplayNameFor(model => model.Foto)
        </th>
        <th></th>
    </tr>

@foreach (var item in Model) {
    <tr>
        <td>
            @Html.DisplayFor(modelItem => item.IdNivel)
        </td>
        <td>
            @Html.DisplayFor(modelItem => item.IdCaballo)
        </td>
        <td>
            <img src="~/img/@Html.DisplayFor(modelItem => item.Foto)" 
             style="width:100px;height:100px"> 
        </td>
       
    </tr>
}

</table>

Ahora crearemos IoC (Inversión de control), para ello crearemos una clase dentro de la carpeta AppStart al que llamaremos IoCCOnfiguration.

IoCConfiguration nos va a servir para configurar la Inyección. Para ello necesitamos que genere el contexto y también el repositorio y así registrar el contexto, el repositorio o controlador…

Al principio ya nos habíamos instalado el NuGet: AutoFac. Y ahora, incluiremos los using AutoFac y using Autofac.Integracion.MVC.

Lo implementaremos haciendo using en los métodos.

Lo primero que haremos será Registrar los controladores y crearemos 3 métodos:
RegistrarController, RegistrarRepos y RegistrarClases.

IoCConfiguration.cs

public class IoCConfiguration
    {
        public static void RegistrarControllers(ContainerBuilder builder)
        {
            builder.RegisterControllers
            (Assembly.GetExecutingAssembly());
        }

        public static void RegistrarRepos(ContainerBuilder builder)
        {
            builder.RegisterType<RepositoryCaballos>()
                .As<IRepositoryCaballos>().InstancePerRequest();
        }

        public static void RegitrarClases(ContainerBuilder builder)
        {
            builder.Register(z => new CaballosContext()).
                            InstancePerRequest();
        }
        public static void Configure()
        {
            ContainerBuilder builder = new ContainerBuilder();

            RegistrarControllers(builder);
            RegistrarRepos(builder);
            RegitrarClases(builder);

            IContainer contenedor = builder.Build();

            DependencyResolver.SetResolver
                (new AutofacDependencyResolver(contenedor));
        }

Dentro del método RegistrarRepos, inyectaremos el tipo de repositorio (la clase) que queramos para nuestro Controller. Y en RegistrarClases registramos los contextos de los que depende un Repositorio.

Por último, crearemos el método Configure() y en él crearemos el constructor del contenedor y registraremos las dependencias. Una vez construyamos el contenedor le indicaremos a MVC qué contenedor utilizará la para la inyección de dependencias.

CODIGO: IoCConfiguration.cs - Metodo Configure

public static void Configure()
        {
            ContainerBuilder builder = new ContainerBuilder();

            RegistrarControllers(builder);
            RegistrarRepos(builder);
            RegitrarClases(builder);

            IContainer contenedor = builder.Build();

            DependencyResolver.SetResolver
                (new AutofacDependencyResolver(contenedor));
        }

Y Por último, para finalizar ya podemos ir a nuestra carpeta Views y abrir la vista que hemos creado desde el Controlador donde podemos ver el resultado y nos mostrará la lista de Caballos.

¡Y con esto finalizamos este post sobre inyecciones de dependencia con inversion de control, muchas gracias Un saludo!