autofac Tutorial
Empezando con autofac

Observaciones

Instalación de Autofac

Para usar Autofac en su proyecto, todo lo que tiene que hacer es instalar Autofac desde NuGet Package Manager. Abra la solución que desea utilizar Autofac, luego seleccione Manager NuGet Packages for Solution... yendo a:

Tools -> NuGet Package Manager -> Manager NuGet Packages for Solution...

En la pestaña NuGet-Solution , escriba "Autofac" en el cuadro de búsqueda. Asegúrese de que está en la sección "Examinar". Instale la primera opción como se muestra en la imagen a continuación (tome nota de las regiones marcadas en la imagen):

La instalación a través de NuGet agregará automáticamente Autofac en las Referencias de los proyectos que se seleccionaron durante la instalación.

Echa un vistazo a la documentación oficial .

Configurando Autofac

Este ejemplo mostrará cómo comenzar con Inverion of Control utilizando Autofac con un proyecto relativamente simple, siguiendo de cerca los documentos oficiales de inicio .

1. Cree una aplicación de consola desde File -> New -> Project -> Console Application

2. Instala Autofac para este proyecto. Puedes echar un vistazo aquí Instalando Autofac

3. Agrega 2 interfaces y 2 clases, con los siguientes nombres:

     Interfaces  |  Classes
   --------------------------
   IOutput       | ConsoleOutput (implementing IOutput)
   IDateWriter   | TodayWriter (implementing IDateWriter)
   

Por simplicidad, no se muestran las declaraciones de uso ni los espacios de nombres.

IOuput.cs

public interface IOutput
{
    void Write(string content);
}

ConsoleOutput.cs

public class ConsoleOutput : IOutput
{
    public void Write(string content)
    {
        Console.WriteLine(content);
    }
}

IDateWriter.cs

public interface IDateWriter
{
    void WriteDate();
}

HoyWriter.cs

public class TodayWriter : IDateWriter
{
    private IOutput _output;

    public TodayWriter(IOutput output)
    {
        _output = output;
    }

    public void WriteDate()
    {
        _output.Write(DateTime.Today.ToShortDateString());
    }
}

Hasta ahora el código ha sido sencillo y simple. Vayamos a la parte donde se realiza la inyección de dependencia automática, lo que, por supuesto, está siendo realizado por Autofac.

Reemplace la clase de Program en el archivo Program.cs con este código (Visual Studio crea automáticamente la clase de Program en la creación del proyecto. Si no existe, siga adelante y cree una):

class Program
{
    private static IContainer Container { get; set; }

    static void Main(string[] args)
    {
        var builder = new ContainerBuilder();
        builder.RegisterType<ConsoleOutput>().As<IOutput>();
        builder.RegisterType<TodayWriter>().As<IDateWriter>();
        Container = builder.Build();

        WriteDate();
    }

    public static void WriteDate()
    {
        using (var scope = Container.BeginLifetimeScope())
        {
            var writer = scope.Resolve<IDateWriter>();
            writer.WriteDate();
        }
    }
}

Cuando se ejecuta, la salida debe ser la fecha actual en la consola. Ha utilizado con éxito Autofac en su proyecto para inyectar dependencias automáticamente.

Aquí está lo que está pasando bajo el capó:

1. Al inicio de la aplicación, estamos creando un ContainerBuilder y registrando nuestros Componentes con él. Un componente en términos simples es un tipo .NET que implementa una interfaz y, por lo tanto, expone algunos servicios . Leer servicios vs. componentes .

2. Luego registramos nuestros componentes (clases) con los servicios (interfaces) que exponen. Cuando se registra, Autofac sabe qué instancia de una clase crear cuando se debe resolver una interfaz.

3. Finalmente, cuando ejecutamos el programa:

   • El método WriteDate() (en Main() ) le pide a Autofac un IDateWriter .
   • Autofac ve que IDateWriter asigna a TodayWriter por lo que comienza a crear un TodayWriter .
   • Autofac ve que el TodayWriter necesita una IOutput en su constructor.
   • Autofac ve que IOutput asigna a ConsoleOutput por lo que crea una nueva instancia de ConsoleOutput .
   • Autofac usa la nueva instancia de ConsoleOutput para terminar de construir el TodayWriter .
   • Autofac devuelve el construido totalmente TodayWriter para WriteDate() para consumir.