Inyección de Dependencias en C#

La inyección de dependencias (IoC – Inversion of Control) es un patrón de diseño utilizado en C# y otros lenguajes de programación para gestionar las dependencias de objetos en una aplicación. En C#, puedes implementar IoC utilizando contenedores de IoC como Unity, Autofac, Ninject, y otros. A continuación, te mostraré un ejemplo simple de inyección de dependencias utilizando Autofac como contenedor de IoC:

Agrega Autofac a tu proyecto. Puedes hacerlo instalando el paquete NuGet correspondiente:

Install-Package Autofac

Crea una interfaz y una clase que implemente esa interfaz. En este ejemplo, crearemos una interfaz ISaludoService y una clase SaludoService que implementa la interfaz:

public interface ISaludoService
{
    string Saludar(string nombre);
}

public class SaludoService : ISaludoService
{
    public string Saludar(string nombre)
    {
        return $"¡Hola, {nombre}!";
    }
}

Configura Autofac para gestionar la inyección de dependencias en tu aplicación:

using Autofac;

class Program
{
    static void Main()
    {
        // Crea un contenedor Autofac
        var builder = new ContainerBuilder();

        // Registra tus componentes y servicios en el contenedor
        builder.RegisterType<SaludoService>().As<ISaludoService>();

        // Construye el contenedor
        var container = builder.Build();

        // Resuelve las dependencias utilizando Autofac
        using (var scope = container.BeginLifetimeScope())
        {
            var saludoService = scope.Resolve<ISaludoService>();
            var mensaje = saludoService.Saludar("John");
            Console.WriteLine(mensaje);
        }
    }
}

En este ejemplo:

• Creamos un contenedor Autofac utilizand ContainerBuilder.
• Registramos SaludoService como implementación de ISaludoService en el contenedor.
• Construimos el contenedor utilizando Build().
• Resolvemos las dependencias utilizando el contenedor en un ámbito (scope) y luego llamamos al método Saludar de SaludoService.

La inyección de dependencias permite que los componentes de tu aplicación obtengan sus dependencias de manera automática, lo que facilita la creación de aplicaciones más flexibles y mantenibles. Puedes configurar más componentes y servicios en el contenedor según tus necesidades específicas.

Implementación de inyección de dependencias en una aplicación web MVC.

La implementación de la inyección de dependencias en una aplicación web MVC en C# es similar a la que se mostró en el ejemplo anterior, pero adaptada al entorno web. A continuación, te mostraré cómo hacerlo utilizando ASP.NET MVC y Autofac como contenedor de IoC.

1. Crea un proyecto de aplicación web ASP.NET MVC si aún no tienes uno configurado.
2. Agrega Autofac a tu proyecto web. Puedes hacerlo instalando el paquete NuGet correspondiente:

Install-Package Autofac.Mvc5

• Define una interfaz y una clase que implemente esa interfaz, similar al ejemplo anterior. Por ejemplo, crearemos una interfaz ISaludoService y una clase SaludoService que implementa la interfaz:

public interface ISaludoService
{
    string Saludar(string nombre);
}

public class SaludoService : ISaludoService
{
    public string Saludar(string nombre)
    {
        return $"¡Hola, {nombre}!";
    }
}

Configura Autofac para gestionar la inyección de dependencias en tu aplicación web. Para ello, puedes utilizar la clase AutofacConfig dentro de la carpeta App_Start en tu proyecto.

using System.Web.Mvc;
using Autofac;
using Autofac.Integration.Mvc;

public class AutofacConfig
{
    public static void RegisterDependencies()
    {
        var builder = new ContainerBuilder();

        // Registra tus componentes y servicios en el contenedor
        builder.RegisterType<SaludoService>().As<ISaludoService>();

        // Registra los controladores de MVC en Autofac
        builder.RegisterControllers(typeof(MvcApplication).Assembly);

        // Construye el contenedor
        var container = builder.Build();

        // Configura MVC para usar Autofac como su contenedor de IoC
        DependencyResolver.SetResolver(new AutofacDependencyResolver(container));
    }
}

Llama al método RegisterDependencies en el archivo Global.asax.cs dentro de la carpeta App_Start en el método Application_Start:

protected void Application_Start()
{
    AreaRegistration.RegisterAllAreas();
    RouteConfig.RegisterRoutes(RouteTable.Routes);
    AutofacConfig.RegisterDependencies(); // Registra las dependencias con Autofac
}

Ahora, puedes utilizar la inyección de dependencias en tus controladores de ASP.NET MVC. Por ejemplo, inyecta ISaludoService en tu controlador:

public class HomeController : Controller
{
    private readonly ISaludoService _saludoService;

    public HomeController(ISaludoService saludoService)
    {
        _saludoService = saludoService;
    }

    public ActionResult Index()
    {
        var mensaje = _saludoService.Saludar("John");
        ViewBag.Mensaje = mensaje;
        return View();
    }
}

En este ejemplo, el controlador HomeController recibe una instancia de ISaludoService a través de la inyección de dependencias. Puedes utilizar ISaludoService en tus acciones para realizar operaciones y mostrar datos en tus vistas.

La inyección de dependencias en ASP.NET MVC facilita la gestión de las dependencias de tus controladores y otros componentes de la aplicación, lo que la hace más flexible y mantenible.