Autofac .NET 6 (Cómo funciona para desarrolladores)

En el ámbito del desarrollo .NET, la gestión eficaz de las dependencias es crucial para crear aplicaciones escalables, mantenibles y comprobables. Inyección de dependencia (DI) los contenedores desempeñan un papel fundamental en la consecución de estos objetivos al facilitar la inversión del control (IoC) principio. Entre la plétora de bibliotecas de mecanismos de alojamiento genérico disponibles, Autofac destaca como un marco para .NET rico en funciones y extensible.

En este artículo, nos embarcaremos en un viaje para explorar Autofac .NET 6, desentrañando sus características y ventajas para mostrar ejemplos prácticos de su uso. Más adelante en este artículo, conoceremos IronPDF, una biblioteca de generación de PDF de Iron Software. También presentaremos un caso de uso conjunto de Autofac.NET e IronPDF.

Comprender Autofac .NET

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

Características de Autofac

1. Construcción de contenedores y registro de componentes: Puedes construir contenedores usando Autofac registrando componentes en la clase de inicio. Puede registrar componentes utilizando lambdas, tipos o instancias preconstruidas.

    public class Startup
    {
        public void ConfigureContainer()
        {
            var builder = new ContainerBuilder(); // host sub property builder
            builder.RegisterInstance(new TaskRepository()).As<ITaskRepository>();
            builder.RegisterType<TaskController>();
            builder.Register(c => new LogManager(DateTime.Now)).As<ILogger>();
            // Scan an assembly for components
            builder.RegisterAssemblyTypes(myAssembly).Where(t => t.Name.EndsWith("Repository")).AsImplementedInterfaces();
            var container = builder.Build();
        }
    }

    public class Startup
    {
        public void ConfigureContainer()
        {
            var builder = new ContainerBuilder(); // host sub property builder
            builder.RegisterInstance(new TaskRepository()).As<ITaskRepository>();
            builder.RegisterType<TaskController>();
            builder.Register(c => new LogManager(DateTime.Now)).As<ILogger>();
            // Scan an assembly for components
            builder.RegisterAssemblyTypes(myAssembly).Where(t => t.Name.EndsWith("Repository")).AsImplementedInterfaces();
            var container = builder.Build();
        }
    }

IRON VB CONVERTER ERROR developers@ironsoftware.com

2. Expresar dependencias: Autofac puede inyectar parámetros de constructor, manejar inyección de propiedades e inyección de métodos.

    public class TaskController
    {
        private ITaskRepository _repository;
        private ILogger _logger;

        public TaskController(ITaskRepository repository, ILogger logger)
        {
            this._repository = repository;
            this._logger = logger;
        }
    }

    public class TaskController
    {
        private ITaskRepository _repository;
        private ILogger _logger;

        public TaskController(ITaskRepository repository, ILogger logger)
        {
            this._repository = repository;
            this._logger = logger;
        }
    }

IRON VB CONVERTER ERROR developers@ironsoftware.com

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

    public class CarTransportModule : Module
    {
        public bool ObeySpeedLimit { get; set; }

        protected override void Load(ContainerBuilder builder)
        {
            builder.RegisterType<Car>().As<IVehicle>();
            if (ObeySpeedLimit)
                builder.RegisterType<SaneDriver>().As<IDriver>();
            else
                builder.RegisterType<CrazyDriver>().As<IDriver>();
        }
    }

    public class CarTransportModule : Module
    {
        public bool ObeySpeedLimit { get; set; }

        protected override void Load(ContainerBuilder builder)
        {
            builder.RegisterType<Car>().As<IVehicle>();
            if (ObeySpeedLimit)
                builder.RegisterType<SaneDriver>().As<IDriver>();
            else
                builder.RegisterType<CrazyDriver>().As<IDriver>();
        }
    }

IRON VB CONVERTER ERROR developers@ironsoftware.com

4. Puntos de extensión sencillos: Autofac proporciona eventos de activación para personalizar la activación o liberación de componentes.

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

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

IRON VB CONVERTER ERROR developers@ironsoftware.com

Características principales de Autofac.NET

1. Registro flexible de componentes: Autofac permite a los desarrolladores registrar componentes utilizando diversas técnicas de registro, como el registro manual, el escaneado de ensamblajes y el registro basado en atributos. Esta flexibilidad permite un control preciso de la instanciación y configuración de los componentes.

2. Gestión del tiempo de vida: Autofac soporta varios ámbitos de vida de objetos, incluyendo singleton, instancia por dependencia, instancia por ámbito de vida e instancia por petición. Este control granular sobre el tiempo de vida de los objetos garantiza una utilización eficiente de los recursos y evita fugas de memoria en aplicaciones de larga ejecución.

3. Resolución automática de dependencias: Autofac resuelve automáticamente las dependencias basándose en los registros de componentes registrados y sus dependencias. Este cableado automático simplifica la configuración de grafos de objetos complejos y favorece el acoplamiento flexible entre componentes.

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

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

6. Integración con .NET Core y .NET Core: Autofac se integra a la perfección con .NET Core y ASP.NET Core, proporcionando un soporte de primera clase para la inyección de dependencias en aplicaciones web y microservicios modernos. Aprovecha la abstracción de proveedor de servicios incorporada para garantizar la compatibilidad y la interoperabilidad con el ecosistema .NET.

Ejemplos prácticos con Autofac.NET

Veamos 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 escaneado de conjuntos y el registro basado en módulos, hemos demostrado la flexibilidad que ofrece Autofac en la gestión de dependencias. Utilizando estas técnicas, los desarrolladores pueden agilizar el proceso de inyección de dependencias de sus aplicaciones, mejorando su mantenimiento y escalabilidad.

Ventajas de utilizar Autofac.NET

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

2. Comprobabilidad y mantenibilidad: Al fomentar el acoplamiento flexible y la inversión de dependencias, Autofac mejora la capacidad de comprobación y mantenimiento de las aplicaciones .NET, lo que permite realizar pruebas unitarias y refactorizaciones con facilidad.

3. Rendimiento y escalabilidad: El rendimiento ligero y eficiente en tiempo de ejecución de Autofac lo hace adecuado para aplicaciones de alto rendimiento y sistemas escalables con grandes grafos de objetos.

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 aplicación.

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

Licencia Autofac

Autofac cuenta con una licencia MIT que permite su uso gratuito con fines comerciales y de desarrollo.

Presentación de IronPDF de Iron Software

IronPDF es una robusta biblioteca PDF en C# diseñada para proporcionar una solución completa para la gestión de archivos PDF en proyectos .NET. Tanto si necesita crear, editar, exportar, proteger, cargar o manipular documentos PDF, IronPDF tiene las herramientas que necesita. Estas son algunas de sus características y aplicaciones más destacadas:

Características principales

• Conversión de HTML a PDF: Convierte sin esfuerzo contenidos HTML a PDF. Genere PDF a partir de HTML, MVC, ASPX e imágenes.

• Gestión de PDF: Con más de 50 funciones, IronPDF permite firmar, editar y extraer contenido de PDF, facilitando las firmas digitales y las modificaciones.

• Compatibilidad multiplataforma: Compatible con C#, F# y VB.NET, IronPDF funciona en varias versiones de .NET, incluidas .NET Core, .NET Standard y .NET Framework. También está disponible para Java, Node.js y Python.

Compatibilidad y entornos

• Versiones .NET: Compatible con C#, VB.NET y F#.
• Tipos de proyecto: Adecuado para web (Blazor y WebForms), escritorio (WPF Y MAUI)y aplicaciones de consola.
• Entornos de aplicación: Compatible con Windows, Linux, Mac, Docker, Azure, AWS y más.

• IDEs: Se integra perfectamente con Microsoft Visual Studio y JetBrains Rider.

• OS y procesadores: Funciona con Windows, Mac y Linux (x64, x86, ARM).

Normas y edición de PDF

• Compatibilidad: Compatible con varias versiones de PDF (1.2 - 1.7)PDF/UA y PDF/A.
• Personalización: Establezca las propiedades, la seguridad y la compresión de los archivos PDF.
• Metadatos y estructura: Edite los metadatos, el historial de revisiones y la estructura del documento.
• Plantillas y configuración: Aplica plantillas de página, encabezados, pies de página y ajustes de página.

Optimización del rendimiento

• Eficacia: Soporte completo multithreading y async para la generación eficiente de PDF.

• Prioridad: Se centra en la precisión, la facilidad de uso y la velocidad.

  Veamos ahora un ejemplo práctico con estas dos bibliotecas.

Generar Documento PDF Usando Autofac.NET y IronPDF

En primer lugar, vamos a crear una aplicación de consola de Visual Studio

Indique el nombre y la ubicación del proyecto.

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

A continuación, instale la biblioteca IronPDF desde el paquete NuGet del gestor de paquetes de Visual Studio

Instalar Autofac desde el paquete NuGet del gestor de paquetes de Visual Studio

Ejemplo de código: Autofac y IronPDF

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

Código Explicación

Desglosemos el fragmento de código que nos has proporcionado:

1. Configuración de ChromePdfRenderer:

   • El código inicializa una instancia de ChromePdfRenderer para renderizar PDFs.

2. Preparación de contenidos HTML:

   • La variable content es una cadena HTML que se utilizará para generar el PDF.

   • Incluye una etiqueta <h1> con el título "Demostración de Autofac con IronPDF".

3. Configuración del contenedor Autofac:

   • El código crea una instancia de ContainerBuilder llamada builder.

   • Este es el primer paso para configurar un contenedor Autofac para inyección de dependencias.

4. Registro manual de tipos:

   • Registra un tipo MyService como implementación de la interfaz IMyService.

   • Esto permite a Autofac resolver las dependencias cuando sea necesario.

5. Registro de tipos mediante la exploración de conjuntos:

   • Escanea el ensamblaje que contiene el tipo AutoFac.

   • Registra los tipos cuyos nombres terminan en "Repository" como implementaciones de sus correspondientes interfaces.

6. Registro de módulos:

   • Registra un módulo llamado MiMódulo.

   • Los módulos permiten agrupar inscripciones relacionadas.

7. Construir el contenedor:

   • El contenedor se construye a partir de los componentes registrados mediante builder.Build() método.

8. Resolver dependencias:

   • Dentro del alcance de toda una vida (utilizando (var scope = contenedor.BeginLifetimeScope()))resuelve una instancia de IMyService.

   • Se llama al método DoSomething en el servicio resuelto.

9. Generación de PDF:

   • Se crea un PDF a partir del contenido utilizando el ChromePdfRenderer.

   • El PDF resultante se guarda como "autofac.pdf".

Salida

Licencia 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"
}

Conclusión

En conclusión, Autofac.NET se presenta como un contenedor de inyección de dependencias para .NET robusto y rico en funciones, que permite a los desarrolladores crear aplicaciones modulares, mantenibles y extensibles. Tanto si desarrolla aplicaciones de escritorio como servicios web o soluciones nativas en la nube, Autofac ofrece una base fiable para gestionar las dependencias y promover las mejores prácticas en el desarrollo .NET.

IronPDF es una biblioteca versátil y rica en funciones para generar, editar y leer documentos PDF. Junto con la biblioteca IronPDF de Iron Software para leer y generar documentos PDF, los desarrolladores pueden adquirir conocimientos avanzados para desarrollar aplicaciones modernas.