Autofac .NET 6 (Cómo Funciona para Desarrolladores)

Entender Autofac .NET

Autofac es un contenedor IoC de código abierto para .NET que proporciona soporte integral para inyección de dependencias y registro de componentes en aplicaciones como web APIs. Desarrollado por Nicholas Blumhardt y mantenido por una comunidad dedicada, Autofac ofrece una solución sólida y flexible para gestionar el ciclo de vida de los objetos, resolver dependencias y componer componentes de aplicación.

Para obtener más información sobre cómo Autofac mejora las aplicaciones .NET, explore los recursos proporcionados por la biblioteca .NET PDF de IronPDF, que resalta características avanzadas para la generación y manipulación de PDF. También puede profundizar en la biblioteca .NET Barcode de IronBarcode para ver aplicaciones prácticas de la inyección de dependencias en la generación de códigos de barras.

Para obtener conocimientos adicionales y ejemplos prácticos utilizando Autofac en escenarios del mundo real, visite la página oficial de Iron Software, donde encontrará una suite completa de productos como IronOCR e IronXL que se integran sin problemas con Autofac y mejoran el proceso de desarrollo .NET.

Características de Autofac

1. Creación de contenedores y registro de componentes: puede crear contenedores utilizando Autofac registrando componentes en la clase de inicio. Es posible registrar componentes utilizando lambdas, tipos, o instancias pre-construidas.

   public class Startup
   {
       public void ConfigureContainer()
       {
           var builder = new ContainerBuilder(); // Create a new container builder
           builder.RegisterInstance(new TaskRepository()).As<ITaskRepository>(); // Register an instance for ITaskRepository
           builder.RegisterType<TaskController>(); // Register TaskController type
           builder.Register(c => new LogManager(DateTime.Now)).As<ILogger>(); // Use lambda expression to register ILogger
           // Scan an assembly for components and register them
           builder.RegisterAssemblyTypes(myAssembly).Where(t => t.Name.EndsWith("Repository")).AsImplementedInterfaces();
           var container = builder.Build(); // Build the container
       }
   }

   public class Startup
   {
       public void ConfigureContainer()
       {
           var builder = new ContainerBuilder(); // Create a new container builder
           builder.RegisterInstance(new TaskRepository()).As<ITaskRepository>(); // Register an instance for ITaskRepository
           builder.RegisterType<TaskController>(); // Register TaskController type
           builder.Register(c => new LogManager(DateTime.Now)).As<ILogger>(); // Use lambda expression to register ILogger
           // Scan an assembly for components and register them
           builder.RegisterAssemblyTypes(myAssembly).Where(t => t.Name.EndsWith("Repository")).AsImplementedInterfaces();
           var container = builder.Build(); // Build the container
       }
   }

   Public Class Startup
   	Public Sub ConfigureContainer()
   		Dim builder = New ContainerBuilder() ' Create a new container builder
   		builder.RegisterInstance(New TaskRepository()).As(Of ITaskRepository)() ' Register an instance for ITaskRepository
   		builder.RegisterType(Of TaskController)() ' Register TaskController type
   		builder.Register(Function(c) New LogManager(DateTime.Now)).As(Of ILogger)() ' Use lambda expression to register ILogger
   		' Scan an assembly for components and register them
   		builder.RegisterAssemblyTypes(myAssembly).Where(Function(t) t.Name.EndsWith("Repository")).AsImplementedInterfaces()
   		Dim container = builder.Build() ' Build the container
   	End Sub
   End Class

   $vbLabelText   $csharpLabel

2. Dependencias expresas: Autofac puede inyectar parámetros de constructor, manejar la inyección de propiedades y la inyección de métodos.

   public class TaskController
   {
       private ITaskRepository _repository;
       private ILogger _logger;
   
       public TaskController(ITaskRepository repository, ILogger logger)
       {
           _repository = repository; // Assign injected repository to the local variable
           _logger = logger; // Assign injected logger to the local variable
       }
   }

   public class TaskController
   {
       private ITaskRepository _repository;
       private ILogger _logger;
   
       public TaskController(ITaskRepository repository, ILogger logger)
       {
           _repository = repository; // Assign injected repository to the local variable
           _logger = logger; // Assign injected logger to the local variable
       }
   }

   Public Class TaskController
   	Private _repository As ITaskRepository
   	Private _logger As ILogger
   
   	Public Sub New(ByVal repository As ITaskRepository, ByVal logger As ILogger)
   		_repository = repository ' Assign injected repository to the local variable
   		_logger = logger ' Assign injected logger to the local variable
   	End Sub
   End Class

   $vbLabelText   $csharpLabel

3. Sistema de módulos flexible: Los módulos de Autofac logran un equilibrio entre la configuración XML y los registros basados ​​en código. Es posible especificar registros complejos en código o cambiar el comportamiento en el momento de despliegue usando XML.

   public class CarTransportModule : Module
   {
       public bool ObeySpeedLimit { get; set; }
   
       protected override void Load(ContainerBuilder builder)
       {
           builder.RegisterType<Car>().As<IVehicle>(); // Register Car as IVehicle
           if (ObeySpeedLimit)
               builder.RegisterType<SaneDriver>().As<IDriver>(); // Register SaneDriver if speed limit is to be obeyed
           else
               builder.RegisterType<CrazyDriver>().As<IDriver>(); // Register CrazyDriver otherwise
       }
   }

   public class CarTransportModule : Module
   {
       public bool ObeySpeedLimit { get; set; }
   
       protected override void Load(ContainerBuilder builder)
       {
           builder.RegisterType<Car>().As<IVehicle>(); // Register Car as IVehicle
           if (ObeySpeedLimit)
               builder.RegisterType<SaneDriver>().As<IDriver>(); // Register SaneDriver if speed limit is to be obeyed
           else
               builder.RegisterType<CrazyDriver>().As<IDriver>(); // Register CrazyDriver otherwise
       }
   }

   Public Class CarTransportModule
   	Inherits Module
   
   	Public Property ObeySpeedLimit() As Boolean
   
   	Protected Overrides Sub Load(ByVal builder As ContainerBuilder)
   		builder.RegisterType(Of Car)().As(Of IVehicle)() ' Register Car as IVehicle
   		If ObeySpeedLimit Then
   			builder.RegisterType(Of SaneDriver)().As(Of IDriver)() ' Register SaneDriver if speed limit is to be obeyed
   		Else
   			builder.RegisterType(Of CrazyDriver)().As(Of IDriver)() ' Register CrazyDriver otherwise
   		End If
   	End Sub
   End Class

   $vbLabelText   $csharpLabel

4. Puntos de extensión simples: Autofac proporciona eventos de activación para personalizar la activación o el lanzamiento de componentes.

   var builder = new ContainerBuilder();
   builder.RegisterType<Listener>().As<IListener>().OnActivated(e => e.Instance.StartListening()); // Setup activation event
   builder.RegisterType<Processor>().OnActivating(e => e.Instance.Initialize()); // Setup activating event
   var container = builder.Build();

   var builder = new ContainerBuilder();
   builder.RegisterType<Listener>().As<IListener>().OnActivated(e => e.Instance.StartListening()); // Setup activation event
   builder.RegisterType<Processor>().OnActivating(e => e.Instance.Initialize()); // Setup activating event
   var container = builder.Build();

   Dim builder = New ContainerBuilder()
   builder.RegisterType(Of Listener)().As(Of IListener)().OnActivated(Function(e) e.Instance.StartListening()) ' Setup activation event
   builder.RegisterType(Of Processor)().OnActivating(Function(e) e.Instance.Initialize()) ' Setup activating event
   Dim container = builder.Build()

   $vbLabelText   $csharpLabel

Características principales de Autofac.NET

1. Registro de componentes flexible: Autofac permite a los desarrolladores registrar componentes utilizando una variedad de técnicas de registro, incluido el registro manual, el escaneo de ensamblaje y el registro basado en atributos. Esta flexibilidad permite un control detallado sobre la instanciación y configuración de componentes.

2. Gestión del tiempo de vida: Autofac admite diversos ámbitos de vida de los objetos, como singleton, instancia por dependencia, instancia por ámbito de vida e instancia por solicitud. Este control granular sobre la vida de los objetos garantiza un uso eficiente de los recursos y evita fugas de memoria en aplicaciones de larga duración.

3. Resolución automática de dependencias: Autofac resuelve automáticamente las dependencias en función de los registros de componentes registrados y sus dependencias. Esta conexión automática simplifica la configuración de gráficos de objetos complejos y promueve un acoplamiento flojo entre componentes.

4. Composición del módulo: Autofac permite a los desarrolladores organizar y encapsular registros de componentes utilizando módulos. Los módulos sirven como contenedores lógicos para registros relacionados, facilitando la gestión y el mantenimiento de aplicaciones a gran escala con múltiples componentes.

5. Intercepción y AOP: Autofac proporciona soporte para intercepción y programación orientada a aspectos (AOP) a través de su extensión de intercepción. Con la intercepción, los desarrolladores pueden aplicar preocupaciones transversales como el registro, almacenamiento en caché y seguridad a componentes sin modificar su implementación.

6. Integración con ASP.NET Core y .NET Core : Autofac se integra perfectamente con .NET Core y ASP.NET Core, proporcionando soporte de primera clase para la inyección de dependencia en aplicaciones web y microservicios modernos. Aprovecha la abstracción del proveedor de servicios incorporado para asegurar la compatibilidad e interoperabilidad con el ecosistema .NET.

Ejemplos prácticos con Autofac.NET

Exploremos algunos ejemplos prácticos para ilustrar el uso de Autofac.NET:

public class Program
{
    public static void Main()
    {
        // Setting up Autofac container
        var builder = new ContainerBuilder();

        // Registering types manually
        builder.RegisterType<MyService>().As<IMyService>();

        // Registering types using assembly scanning
        builder.RegisterAssemblyTypes(typeof(MyAssembly).Assembly)
            .Where(t => t.Name.EndsWith("Repository"))
            .AsImplementedInterfaces();

        // Registering modules
        builder.RegisterModule(new MyModule());

        // Building the container
        var container = builder.Build();

        // Resolving dependencies
        using (var scope = container.BeginLifetimeScope())
        {
            var service = scope.Resolve<IMyService>();
            service.DoSomething();
        }
    }
}

public class Program
{
    public static void Main()
    {
        // Setting up Autofac container
        var builder = new ContainerBuilder();

        // Registering types manually
        builder.RegisterType<MyService>().As<IMyService>();

        // Registering types using assembly scanning
        builder.RegisterAssemblyTypes(typeof(MyAssembly).Assembly)
            .Where(t => t.Name.EndsWith("Repository"))
            .AsImplementedInterfaces();

        // Registering modules
        builder.RegisterModule(new MyModule());

        // Building the container
        var container = builder.Build();

        // Resolving dependencies
        using (var scope = container.BeginLifetimeScope())
        {
            var service = scope.Resolve<IMyService>();
            service.DoSomething();
        }
    }
}

Public Class Program
	Public Shared Sub Main()
		' Setting up Autofac container
		Dim builder = New ContainerBuilder()

		' Registering types manually
		builder.RegisterType(Of MyService)().As(Of IMyService)()

		' Registering types using assembly scanning
		builder.RegisterAssemblyTypes(GetType(MyAssembly).Assembly).Where(Function(t) t.Name.EndsWith("Repository")).AsImplementedInterfaces()

		' Registering modules
		builder.RegisterModule(New MyModule())

		' Building the container
		Dim container = builder.Build()

		' Resolving dependencies
		Using scope = container.BeginLifetimeScope()
			Dim service = scope.Resolve(Of IMyService)()
			service.DoSomething()
		End Using
	End Sub
End Class

En esta sección, hemos demostrado la implementación práctica de Autofac.NET para la inyección de dependencias. Desde el registro manual hasta el escaneo de ensamblajes y el registro basado en módulos, hemos mostrado la flexibilidad que Autofac ofrece en la gestión de dependencias. Al utilizar estas técnicas, los desarrolladores pueden simplificar el proceso de inyección de dependencias de su aplicación, mejorando el mantenimiento y la escalabilidad.

Para obtener más información sobre cómo los productos de Iron Software pueden integrarse con aplicaciones .NET para optimizar y mejorar la funcionalidad, explore la documentación de IronPDF donde puede aprender a generar y editar documentos PDF de forma programada, o visite el sitio web de Iron Software para descubrir una amplia gama de poderosas bibliotecas .NET como IronBarcode para leer y escribir códigos de barras, e IronOCR para reconocimiento óptico de caracteres avanzado.

Beneficios del uso de Autofac.NET

1. Simplicidad y flexibilidad: Autofac ofrece una API simple e intuitiva para registrar y resolver componentes, lo que hace que la inyección de dependencia sea fácil de implementar y mantener.

2. Capacidad de prueba y mantenimiento: al promover el acoplamiento flexible y la inversión de dependencia, Autofac mejora la capacidad de prueba y mantenimiento de las aplicaciones .NET , lo que permite realizar pruebas unitarias y refactorizar con facilidad.

3. Rendimiento y escalabilidad: el rendimiento de ejecución liviano y eficiente de Autofac lo hace adecuado para aplicaciones de alto rendimiento y sistemas escalables con gráficos de objetos grandes.

4. Extensibilidad y personalización: la arquitectura extensible de Autofac permite a los desarrolladores ampliar y personalizar el comportamiento de Autofac a través de módulos personalizados, fuentes de registro y componentes de middleware, atendiendo a diversos requisitos de aplicaciones.

5. Comunidad y soporte: con una comunidad activa de desarrolladores y documentación completa, Autofac proporciona excelente soporte y recursos para aprender, solucionar problemas y contribuir al marco.

Presentación de IronPDF de Iron Software

IronPDF es una robusta biblioteca PDF para C# diseñada para proporcionar una solución integral para gestionar PDF en proyectos de .NET. Si las necesidades involucran crear, editar, exportar, asegurar, cargar o manipular documentos PDF, IronPDF dispone de las herramientas necesarias. A continuación se presentan algunas de sus características y aplicaciones destacadas:

• Más información sobre cómo crear PDF con IronPDF
• Cómo editar PDF eficientemente con IronPDF
• Características de seguridad de IronPDF
• Sitio web de Iron Software
• Documentación de IronPDF para guías detalladas

Generación de documentos PDF con Autofac.NET y IronPDF

Primero, creemos una aplicación de consola de Visual Studio

Proporciona el nombre y la ubicación del proyecto.

Para el siguiente paso, seleccione la versión .NET requerida y haga clic en Crear.

Luego instale la biblioteca IronPDF desde el NuGet Package Manager de Visual Studio

Visite la Documentación de IronPDF para más información sobre la instalación y uso de la biblioteca IronPDF.

Instale Autofac desde el NuGet Package Manager de Visual Studio

Aprenda más sobre Autofac visitando la Página de Documentación de Autofac.

using Autofac;
using CacheManager.Core;
using IronPdf;
using System.Reflection;

namespace IronPdfDemos
{
    public class AutoFac
    {
        public static void Execute()
        {
            // Instantiate Cache and ChromePdfRenderer
            var renderer = new ChromePdfRenderer();
            var cache = CacheFactory.Build("ironPdfAutofac", settings =>
            {
                settings.WithDictionaryHandle();
            });

            // Prepare HTML content
            var content = "<h1>Demonstrate Autofac with IronPDF</h1>";
            content += "<p>This is an illustration of using Autofac for dependency injection and IronPDF for generating PDF documents.</p>";
            content += "<h2>Setting up Autofac container</h2>";

            // Setting up Autofac container
            var builder = new ContainerBuilder();
            content += "<p>var builder = new ContainerBuilder();</p>";

            content += "<h2>Registering types manually</h2>";
            // Registering types manually
            builder.RegisterType<MyService>().As<IMyService>();
            content += "<p>builder.RegisterType<MyService>().As<IMyService();</p>";

            content += "<h2>Registering types using assembly scanning</h2>";
            // Registering types using assembly scanning
            builder.RegisterAssemblyTypes(typeof(AutoFac).Assembly)
                .Where(t => t.Name.EndsWith("Repository"))
                .AsImplementedInterfaces();
            content += "<p>builder.RegisterAssemblyTypes(typeof(AutoFac).Assembly).Where(t => t.Name.EndsWith(\"Repository\")).AsImplementedInterfaces();</p>";

            content += "<h2>Registering modules</h2>";
            // Registering modules
            builder.RegisterModule(new MyModule());
            content += "<p>builder.RegisterModule(new MyModule());</p>";

            content += "<h2>Building the container</h2>";
            // Building the container
            var container = builder.Build();
            content += "<p>var container = builder.Build();</p>";

            content += "<h2>Resolving dependencies</h2>";
            // Resolving dependencies
            using (var scope = container.BeginLifetimeScope())
            {
                var service = scope.Resolve<IMyService>();
                service.DoSomething();
            }
            content += "<p>var service = scope.Resolve<IMyService();</p>";

            // Create a PDF from the HTML string using C#
            var pdf = renderer.RenderHtmlAsPdf(content);
            // Export to a file or Stream
            pdf.SaveAs("autofac.pdf");
            Console.WriteLine("We are done...");
            Console.ReadKey();
        }
    }

    internal interface IMyService
    {
        void DoSomething();
    }

    internal class MyModule : Module
    {
        protected override void Load(ContainerBuilder builder)
        {
            // Register module dependencies here
        }
    }

    internal class MyService : IMyService
    {
        public void DoSomething()
        {
            Console.WriteLine("DoSomething");
        }
    }
}

using Autofac;
using CacheManager.Core;
using IronPdf;
using System.Reflection;

namespace IronPdfDemos
{
    public class AutoFac
    {
        public static void Execute()
        {
            // Instantiate Cache and ChromePdfRenderer
            var renderer = new ChromePdfRenderer();
            var cache = CacheFactory.Build("ironPdfAutofac", settings =>
            {
                settings.WithDictionaryHandle();
            });

            // Prepare HTML content
            var content = "<h1>Demonstrate Autofac with IronPDF</h1>";
            content += "<p>This is an illustration of using Autofac for dependency injection and IronPDF for generating PDF documents.</p>";
            content += "<h2>Setting up Autofac container</h2>";

            // Setting up Autofac container
            var builder = new ContainerBuilder();
            content += "<p>var builder = new ContainerBuilder();</p>";

            content += "<h2>Registering types manually</h2>";
            // Registering types manually
            builder.RegisterType<MyService>().As<IMyService>();
            content += "<p>builder.RegisterType<MyService>().As<IMyService();</p>";

            content += "<h2>Registering types using assembly scanning</h2>";
            // Registering types using assembly scanning
            builder.RegisterAssemblyTypes(typeof(AutoFac).Assembly)
                .Where(t => t.Name.EndsWith("Repository"))
                .AsImplementedInterfaces();
            content += "<p>builder.RegisterAssemblyTypes(typeof(AutoFac).Assembly).Where(t => t.Name.EndsWith(\"Repository\")).AsImplementedInterfaces();</p>";

            content += "<h2>Registering modules</h2>";
            // Registering modules
            builder.RegisterModule(new MyModule());
            content += "<p>builder.RegisterModule(new MyModule());</p>";

            content += "<h2>Building the container</h2>";
            // Building the container
            var container = builder.Build();
            content += "<p>var container = builder.Build();</p>";

            content += "<h2>Resolving dependencies</h2>";
            // Resolving dependencies
            using (var scope = container.BeginLifetimeScope())
            {
                var service = scope.Resolve<IMyService>();
                service.DoSomething();
            }
            content += "<p>var service = scope.Resolve<IMyService();</p>";

            // Create a PDF from the HTML string using C#
            var pdf = renderer.RenderHtmlAsPdf(content);
            // Export to a file or Stream
            pdf.SaveAs("autofac.pdf");
            Console.WriteLine("We are done...");
            Console.ReadKey();
        }
    }

    internal interface IMyService
    {
        void DoSomething();
    }

    internal class MyModule : Module
    {
        protected override void Load(ContainerBuilder builder)
        {
            // Register module dependencies here
        }
    }

    internal class MyService : IMyService
    {
        public void DoSomething()
        {
            Console.WriteLine("DoSomething");
        }
    }
}

Imports Autofac
Imports CacheManager.Core
Imports IronPdf
Imports System.Reflection

Namespace IronPdfDemos
	Public Class AutoFac
		Public Shared Sub Execute()
			' Instantiate Cache and ChromePdfRenderer
			Dim renderer = New ChromePdfRenderer()
			Dim cache = CacheFactory.Build("ironPdfAutofac", Sub(settings)
				settings.WithDictionaryHandle()
			End Sub)

			' Prepare HTML content
			Dim content = "<h1>Demonstrate Autofac with IronPDF</h1>"
			content &= "<p>This is an illustration of using Autofac for dependency injection and IronPDF for generating PDF documents.</p>"
			content &= "<h2>Setting up Autofac container</h2>"

			' Setting up Autofac container
			Dim builder = New ContainerBuilder()
			content &= "<p>var builder = new ContainerBuilder();</p>"

			content &= "<h2>Registering types manually</h2>"
			' Registering types manually
			builder.RegisterType(Of MyService)().As(Of IMyService)()
			content &= "<p>builder.RegisterType<MyService>().As<IMyService();</p>"

			content &= "<h2>Registering types using assembly scanning</h2>"
			' Registering types using assembly scanning
			builder.RegisterAssemblyTypes(GetType(AutoFac).Assembly).Where(Function(t) t.Name.EndsWith("Repository")).AsImplementedInterfaces()
			content &= "<p>builder.RegisterAssemblyTypes(typeof(AutoFac).Assembly).Where(t => t.Name.EndsWith(""Repository"")).AsImplementedInterfaces();</p>"

			content &= "<h2>Registering modules</h2>"
			' Registering modules
			builder.RegisterModule(New MyModule())
			content &= "<p>builder.RegisterModule(new MyModule());</p>"

			content &= "<h2>Building the container</h2>"
			' Building the container
			Dim container = builder.Build()
			content &= "<p>var container = builder.Build();</p>"

			content &= "<h2>Resolving dependencies</h2>"
			' Resolving dependencies
			Using scope = container.BeginLifetimeScope()
				Dim service = scope.Resolve(Of IMyService)()
				service.DoSomething()
			End Using
			content &= "<p>var service = scope.Resolve<IMyService();</p>"

			' Create a PDF from the HTML string using C#
			Dim pdf = renderer.RenderHtmlAsPdf(content)
			' Export to a file or Stream
			pdf.SaveAs("autofac.pdf")
			Console.WriteLine("We are done...")
			Console.ReadKey()
		End Sub
	End Class

	Friend Interface IMyService
		Sub DoSomething()
	End Interface

	Friend Class MyModule
		Inherits Module

		Protected Overrides Sub Load(ByVal builder As ContainerBuilder)
			' Register module dependencies here
		End Sub
	End Class

	Friend Class MyService
		Implements IMyService

		Public Sub DoSomething() Implements IMyService.DoSomething
			Console.WriteLine("DoSomething")
		End Sub
	End Class
End Namespace

Licencia de IronPDF

IronPDF requiere una clave de licencia. Coloque la clave de licencia en el archivo appSettings.json como se muestra a continuación.

{
  "IronPdf.License.LicenseKey": "The Key Here"
}