Autofac .NET 6 (Como funciona para desenvolvedores)

Entendendo o Autofac .NET

O Autofac é um contêiner IoC de código aberto for .NET que oferece suporte abrangente à injeção de dependência e ao registro de componentes em aplicativos como APIs da Web. Desenvolvido por Nicholas Blumhardt e mantido por uma comunidade dedicada, o Autofac oferece uma solução robusta e flexível para gerenciar o ciclo de vida de objetos, resolver dependências e compor componentes de aplicativos.

Para obter mais informações sobre como o Autofac aprimora seus aplicativos .NET , considere explorar os recursos fornecidos pela Biblioteca PDF .NET da IronPDF , que destaca recursos avançados para geração e manipulação de PDFs. Você também pode explorar a biblioteca de código de barras .NET da IronBarcode para ver aplicações práticas de injeção de dependência na geração de códigos de barras.

Para obter mais informações e exemplos práticos sobre o uso do Autofac em cenários reais, visite a página oficial da IronSoftware , onde você encontrará um conjunto completo de produtos, como o IronOCR e o IronXL , que se integram perfeitamente ao Autofac e aprimoram seu processo de desenvolvimento .NET .

Características do Autofac

1. Criação de contêineres e registro de componentes: Você pode criar contêineres usando o Autofac registrando componentes na classe de inicialização. Você pode registrar componentes usando lambdas, tipos ou instâncias pré-construídas.

   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. Expressar dependências: O Autofac pode injetar parâmetros de construtor, lidar com injeção de propriedades e injeção 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 flexível: Os módulos do Autofac encontram um equilíbrio entre a configuração XML e os registros baseados em código. Você pode especificar registros complexos em código ou alterar o comportamento em tempo de implantação 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. Pontos de extensão simples: O Autofac fornece eventos de ativação para personalizar a ativação ou liberação 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

Principais funcionalidades do Autofac .NET

1. Registro flexível de componentes: O Autofac permite que os desenvolvedores registrem componentes usando diversas técnicas de registro, incluindo registro manual, varredura de assembly e registro baseado em atributos. Essa flexibilidade permite um controle preciso sobre a instanciação e configuração dos componentes.

2. Gerenciamento do Ciclo de Vida: O Autofac suporta vários escopos de ciclo de vida de objetos, incluindo singleton, instância por dependência, instância por escopo de ciclo de vida e instância por requisição. Esse controle granular sobre o ciclo de vida dos objetos garante a utilização eficiente de recursos e evita vazamentos de memória em aplicações de longa duração.

3. Resolução automática de dependências: O Autofac resolve automaticamente as dependências com base nos registros de componentes e suas respectivas dependências. Essa fiação automática simplifica a configuração de grafos de objetos complexos e promove um acoplamento flexível entre os componentes.

4. Composição de Módulos: O Autofac permite que os desenvolvedores organizem e encapsulem registros de componentes usando módulos. Os módulos servem como contêineres lógicos para registros relacionados, facilitando o gerenciamento e a manutenção de aplicações de grande escala com múltiplos componentes.

5. Interceptação e AOP: O Autofac oferece suporte para interceptação e programação orientada a aspectos (AOP) por meio de sua extensão de interceptação. Com a interceptação, os desenvolvedores podem aplicar preocupações transversais, como registro de logs, armazenamento em cache e segurança, aos componentes sem modificar sua implementação.

6. Integração com ASP.NET Core e .NET Core : O Autofac integra-se perfeitamente com o .NET Core e o ASP.NET Core, oferecendo suporte de primeira classe para injeção de dependência em aplicações web modernas e microsserviços. Ele aproveita a abstração de provedor de serviços integrada para garantir compatibilidade e interoperabilidade com o ecossistema .NET .

Exemplos práticos com Autofac .NET

Vamos explorar alguns exemplos práticos para ilustrar o uso do 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

Nesta seção, demonstramos a implementação prática do Autofac .NET para injeção de dependência. Desde o registro manual até a varredura de assemblies e o registro baseado em módulos, demonstramos a flexibilidade que o Autofac oferece no gerenciamento de dependências. Ao utilizar essas técnicas, os desenvolvedores podem simplificar o processo de injeção de dependências de seus aplicativos, melhorando a capacidade de manutenção e a escalabilidade.

Para obter mais informações sobre como os produtos da Iron Software podem se integrar aos seus aplicativos .NET para otimizar e aprimorar ainda mais a funcionalidade, explore a documentação do IronPDF, onde você pode aprender a gerar e editar documentos PDF programaticamente, ou visite o site da Iron Software para descobrir uma ampla gama de poderosas bibliotecas .NET , como o IronBarcode para leitura e gravação de códigos de barras e o IronOCR para reconhecimento óptico de caracteres avançado.

Benefícios de usar o Autofac .NET

1. Simplicidade e Flexibilidade: O Autofac oferece uma API simples e intuitiva para registrar e resolver componentes, facilitando a implementação e a manutenção da injeção de dependências.

2. Testabilidade e Manutenibilidade: Ao promover o baixo acoplamento e a inversão de dependências, o Autofac aprimora a testabilidade e a manutenibilidade de aplicativos .NET , permitindo testes unitários e refatoração com facilidade.

3. Desempenho e escalabilidade: O desempenho de tempo de execução leve e eficiente do Autofac o torna adequado para aplicações de alto desempenho e sistemas escaláveis ​​com grandes grafos de objetos.

4. Extensibilidade e Personalização: A arquitetura extensível do Autofac permite que os desenvolvedores estendam e personalizem o comportamento do Autofac por meio de módulos personalizados, fontes de registro e componentes de middleware, atendendo a diversos requisitos de aplicativos.

5. Comunidade e Suporte: Com uma comunidade ativa de desenvolvedores e documentação abrangente, o Autofac oferece excelente suporte e recursos para aprendizado, solução de problemas e contribuição para o framework.

Apresentando o IronPDF da Iron Software

IronPDF é uma biblioteca robusta em C# para PDFs, projetada para fornecer uma solução completa para o gerenciamento de PDFs em projetos .NET . Seja para criar, editar, exportar, proteger, carregar ou manipular documentos PDF, o IronPDF tem as ferramentas que você precisa. Aqui estão algumas de suas características e aplicações mais marcantes:

Saiba mais sobre como criar PDFs com o IronPDF. Descubra como editar PDFs de forma eficiente com o IronPDF.

• Explore os recursos de segurança do IronPDF
• Visite o site da Iron Software para obter mais detalhes. Consulte a documentação do IronPDF para obter orientações detalhadas.

Gere documentos PDF usando Autofac .NET e IronPDF.

Primeiro, vamos criar um aplicativo de console do Visual Studio.

Forneça o nome e a localização do projeto.

Na próxima etapa, selecione a versão do .NET desejada e clique em Criar.

Em seguida, instale a biblioteca IronPDF a partir do pacote NuGet no Gerenciador de Pacotes do Visual Studio.

Visite a documentação do IronPDF para obter mais informações sobre como instalar e utilizar a biblioteca IronPDF .

Instale o Autofac a partir do pacote NuGet no Gerenciador de Pacotes do Visual Studio.

Saiba mais sobre o Autofac visitando a página de documentação do 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

Licença IronPDF

O IronPDF requer uma chave de licença. Insira a chave de licença no arquivo appSettings.json conforme mostrado abaixo.

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