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 tus aplicaciones .NET, considera explorar 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 puedes 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.

Involúcrate con conocimientos adicionales y ejemplos prácticos utilizando Autofac en escenarios del mundo real visitando la página oficial de Iron Software, donde encontrarás una suite completa de productos como IronOCR e IronXL que se integran sin problemas con Autofac y mejoran tu 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. Puedes 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
       }
   }

   $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
       }
   }

   $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. Puedes 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
       }
   }

   $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();

   $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 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();
        }
    }
}

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 tus aplicaciones .NET para optimizar y mejorar la funcionalidad, explora la documentación de IronPDF donde puedes aprender a generar y editar documentos PDF de forma programada, o visita 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 tus necesidades involucran crear, editar, exportar, asegurar, cargar o manipular documentos PDF, IronPDF tiene las herramientas que necesitas. Aquí tienes algunas de sus características y aplicaciones destacadas:

• Aprende más sobre cómo crear PDF con IronPDF
• Descubre cómo editar PDF eficientemente con IronPDF
• Explora las características de seguridad de IronPDF
• Visita el sitio web de Iron Software para más detalles
• Consulta la 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, selecciona la versión .NET requerida y haz clic en Crear.

Luego instala la biblioteca IronPDF desde el NuGet Package Manager desde Visual Studio

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

Instala Autofac desde el NuGet Package Manager desde Visual Studio

Aprende 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");
        }
    }
}

Licencia de IronPDF

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

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