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. Los contenedores de inyección de dependencias (DI) desempeñan un papel fundamental en la consecución de estos objetivos al facilitar el principio de inversión de control (IoC). 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 potente 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.

Para obtener más información sobre cómo Autofac mejora tus aplicaciones .NET, considera explorar los recursos proporcionados por la biblioteca de PDF de IronPDF para .NET, que destaca las funciones avanzadas para la generación y manipulación de PDFs. También puedes profundizar en la Biblioteca de Códigos de Barras .NET de IronBarcode para ver aplicaciones prácticas de la inyección de dependencias en la generación de códigos de barras.

Acceda a conocimientos adicionales y ejemplos prácticos utilizando Autofac en escenarios del mundo real visitando la página oficial de IronSoftware, donde encontrará una suite completa de productos como IronOCR e IronXL que se integran perfectamente con Autofac y mejoran su proceso de desarrollo en .NET.

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. Dependencias de Express: 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)
        {
            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 Flexibles: Los módulos de 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 Simples: 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 de Componentes Flexible: Autofac permite a los desarrolladores registrar componentes utilizando una variedad de técnicas de registro, incluyendo el registro manual, el escaneo 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 de Vida Útil: Autofac admite varios alcances de vida útil de objetos, incluidos singleton, instancia por dependencia, instancia por alcance de vida útil y instancia por solicitud. Este control granular sobre las vidas útiles de los objetos asegura una utilización eficiente de los recursos y previene 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 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, lo que facilita la gestión y el mantenimiento de aplicaciones a gran escala con múltiples componentes.

5. Intercepción y AOP: Autofac ofrece soporte para la intercepción y la programación orientada a aspectos (AOP) a través de su extensión de intercepció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 de ASP.NET Core y .NET Core: Autofac se integra sin problemas con .NET Core y ASP.NET Core, proporcionando un soporte de primera clase para la inyección de dependencias en aplicaciones web modernas y microservicios. 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.

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

Ventajas de utilizar Autofac.NET

1. Simplicidad y Flexibilidad: Autofac ofrece una API simple e intuitiva para registrar y resolver componentes, lo que facilita la implementación y el mantenimiento de la inyección de dependencias.

2. Prueba y Mantenibilidad: Al promover la baja acoplamiento y la inversión de dependencias, Autofac mejora la capacidad de prueba y la mantenibilidad de las aplicaciones .NET, permitiendo realizar pruebas unitarias y refactorización con facilidad.

3. Rendimiento y Escalabilidad: El rendimiento ligero y eficiente de tiempo de ejecución de Autofac lo hace adecuado para aplicaciones de alto rendimiento y sistemas escalables con grandes gráficos de objetos.

4. Extensibilidad y Personalización: La arquitectura extensible de Autofac permite a los desarrolladores extender y personalizar el comportamiento de Autofac a través de módulos personalizados, fuentes de registro y componentes de middleware, adaptándose a los diversos requisitos de la aplicación.

5. Comunidad y Soporte: Con una comunidad activa de desarrolladores y documentación completa, Autofac ofrece un soporte y recursos excelentes para aprender, solucionar problemas y contribuir al framework.

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:

• Obtén más información sobre la creación de PDFs con IronPDF
• Descubre cómo editar PDFs eficientemente con IronPDF
• Explore las funciones de seguridad de IronPDF
• Visite el sitio web de Iron Software para más detalles
• Consulta la documentación de IronPDF para obtener una guía detallada

Características principales

• Conversión de HTML a PDF: Convierte contenido HTML a PDF sin esfuerzo. Genere PDF a partir de HTML, MVC, ASPX e imágenes.
• Gestión de PDF: Con más de 50 funciones, IronPDF te permite firmar, editar y extraer contenido de PDFs, facilitando las firmas digitales y las modificaciones.

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

  Para obtener más información sobre cómo IronPDF puede integrar funcionalidades de PDF en sus proyectos, visite la página del producto IronPDF.

  Para obtener una visión general completa de la oferta de productos de Iron Software, incluidos IronBarcode, IronOCR y más, visite la página de inicio de Iron Software.

Compatibilidad y entornos

• Versiones de .NET: Compatible con C#, VB.NET y F#.
• Tipos de proyectos: Adecuado para aplicaciones web (Blazor y WebForms con IronPDF), de escritorio (WPF y MAUI) y 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.
• Sistemas operativos y procesadores: Funciona en 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: Establecer propiedades, seguridad y compresión para archivos PDF.
• Metadatos y Estructura: Edita metadatos, historial de revisiones y estructura del documento.

• Plantillas y Configuraciones: Aplica plantillas de página, encabezados, pies de página y configuraciones de página.

  Para obtener más información sobre estas características y cómo implementarlas, visite la guía detallada sobre generación y manipulación de PDF en el sitio oficial de IronPDF.

Optimización del rendimiento

• Eficiencia: Soporte completo de multihilo y asincronía para la generación eficiente de PDF.

• Prioridad: Se centra en la precisión, facilidad de uso y 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

Visite la documentación de IronPDF para obtener más información sobre la instalación y utilización de la biblioteca IronPDF.

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

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

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 a partir de contenido HTML, una característica clave de IronPDF.

2. Preparación de contenido HTML:

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

   • Incluye una etiqueta <h1> con el título "Demonstrar 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. Registrar Tipos Manualmente:

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

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

5. Registro de tipos usando escaneo de ensamblado:

   • Escanea el ensamblado 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 MyModule.

   • Los módulos permiten agrupar inscripciones relacionadas.

7. Construyendo el Contenedor:

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

8. Resolviendo dependencias:

   • Dentro de un ámbito de vida (using (var scope = container.BeginLifetimeScope())), se resuelve una instancia de IMyService.

   • El método DoSomething se llama en el servicio resuelto.

9. Generación de PDF:

   • Un PDF es creado a partir del contenido utilizando el ChromePdfRenderer.

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

Salida

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