Autofac .NET 6 (jak to działa dla programistów)

Zrozumienie Autofac .NET

Autofac to kontener IoC typu open source dla platformy .NET, który zapewnia kompleksową obsługę wstrzykiwania zależności i rejestracji komponentów w aplikacjach, takich jak interfejsy API sieci Web. Opracowany przez Nicholasa Blumhardta i utrzymywany przez dedykowaną społeczność, Autofac oferuje solidne i elastyczne rozwiązanie do zarządzania cyklem życia obiektów, rozwiązywania zależności oraz komponowania elementów aplikacji.

Aby uzyskać więcej informacji na temat tego, jak Autofac usprawnia działanie aplikacji .NET, warto zapoznać się z zasobami udostępnionymi przez bibliotekę .NET PDF firmy IronPDF, która podkreśla zaawansowane funkcje generowania i edycji plików PDF. Możesz również zapoznać się z biblioteką IronBarcode dla .NET, aby zobaczyć praktyczne zastosowania wstrzykiwania zależności w generowaniu kodów kreskowych.

Zapoznaj się z dodatkowymi informacjami i praktycznymi przykładami wykorzystania Autofac w rzeczywistych scenariuszach, odwiedzając oficjalną stronę IronSoftware, gdzie znajdziesz kompleksowy zestaw produktów, takich jak IronOCR i IronXL, które płynnie integrują się z Autofac i usprawniają proces tworzenia oprogramowania w środowisku .NET.

Funkcje Autofac

1. Tworzenie kontenerów i rejestracja komponentów: Można tworzyć kontenery przy użyciu Autofac poprzez rejestrację komponentów w klasie startowej. Komponenty można rejestrować za pomocą lambd, typów lub gotowych instancji.

   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. Wyrażanie zależności: Autofac może wstrzykiwać parametry konstruktora, obsługiwać wstrzykiwanie właściwości oraz wstrzykiwanie metod.

   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. Elastyczny system modułów: moduły Autofac zapewniają równowagę między konfiguracją XML a rejestracjami opartymi na kodzie. Można określać złożone rejestracje w kodzie lub zmieniać zachowanie w czasie wdrażania za pomocą 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. Proste punkty rozszerzeń: Autofac udostępnia zdarzenia aktywacji, które pozwalają dostosować aktywację lub zwolnienie komponentów.

   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

Kluczowe funkcje Autofac.NET

1. Elastyczna rejestracja komponentów: Autofac umożliwia programistom rejestrowanie komponentów przy użyciu różnorodnych technik rejestracji, w tym ręcznej rejestracji, skanowania zestawów i rejestracji opartej na atrybutach. Ta elastyczność zapewnia szczegółową kontrolę nad tworzeniem i konfiguracją komponentów.

2. Zarządzanie cyklem życia: Autofac obsługuje różne zakresy cyklu życia obiektów, w tym singleton, instancja na zależność, instancja na zakres cyklu życia oraz instancja na żądanie. Ta szczegółowa kontrola nad cyklem życia obiektów zapewnia efektywne wykorzystanie zasobów i zapobiega wyciekom pamięci w długo działających aplikacjach.

3. Automatyczne rozwiązywanie zależności: Autofac automatycznie rozwiązuje zależności na podstawie zarejestrowanych komponentów i ich zależności. To automatyczne okablowanie upraszcza konfigurację złożonych grafów obiektów i promuje luźne sprzężenie między komponentami.

4. Kompozycja modułów: Autofac umożliwia programistom organizowanie i hermetyzowanie rejestracji komponentów za pomocą modułów. Moduły służą jako logiczne kontenery dla powiązanych rejestracji, ułatwiając zarządzanie i utrzymanie dużych aplikacji z wieloma komponentami.

5. Przechwytywanie i programowanie aspektowe (AOP): Autofac zapewnia obsługę przechwytywania i programowania aspektowego (AOP) za pośrednictwem rozszerzenia przechwytywania. Dzięki przechwytywaniu programiści mogą stosować zagadnienia przekrojowe, takie jak rejestrowanie, buforowanie i zabezpieczenia, do komponentów bez modyfikowania ich implementacji.

6. Integracja z ASP.NET Core i .NET Core: Autofac płynnie integruje się z .NET Core i ASP.NET Core, zapewniając pierwszorzędną obsługę wstrzykiwania zależności w nowoczesnych aplikacjach internetowych i mikrousługach. Wykorzystuje wbudowaną abstrakcję dostawcy usług, aby zapewnić zgodność i interoperacyjność z ekosystemem .NET.

Praktyczne przykłady z Autofac.NET

Przyjrzyjmy się kilku praktycznym przykładom ilustrującym użycie 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

W tej sekcji zaprezentowaliśmy praktyczną implementację Autofac.NET do wstrzykiwania zależności. Od ręcznej rejestracji, przez skanowanie zestawów, po rejestrację opartą na modułach — pokazaliśmy elastyczność, jaką Autofac oferuje w zarządzaniu zależnościami. Korzystając z tych technik, programiści mogą usprawnić proces wstrzykiwania zależności w swojej aplikacji, zwiększając łatwość utrzymania i skalowalność.

Aby uzyskać więcej informacji na temat integracji produktów Iron Software z aplikacjami .NET w celu dalszego usprawnienia funkcjonalności, zapoznaj się z dokumentacją IronPDF, gdzie dowiesz się, jak programowo generować i edytować dokumenty PDF, lub odwiedź stronę Iron Software, aby odkryć szeroką gamę potężnych bibliotek .NET, takich jak IronBarcode do odczytu i zapisu kodów kreskowych oraz IronOCR do zaawansowanego optycznego rozpoznawania znaków.

Korzyści z używania Autofac.NET

1. Prostota i elastyczność: Autofac oferuje proste i intuicyjne API do rejestrowania i rozwiązywania komponentów, dzięki czemu wstrzykiwanie zależności jest łatwe do wdrożenia i utrzymania.

2. Testowalność i łatwość utrzymania: Promując luźne sprzężenie i odwrócenie zależności, Autofac zwiększa testowalność i łatwość utrzymania aplikacji .NET, umożliwiając testy jednostkowe i refaktoryzację z łatwością.

3. Wydajność i skalowalność: Lekka i wydajna wydajność środowiska uruchomieniowego Autofac sprawia, że nadaje się do aplikacji o wysokiej wydajności i skalowalnych systemów z dużymi grafami obiektów.

4. Rozszerzalność i dostosowywanie: Rozszerzalna architektura Autofac pozwala programistom rozszerzać i dostosowywać zachowanie Autofac za pomocą niestandardowych modułów, źródeł rejestracji i komponentów oprogramowania pośredniczącego, odpowiadając na różnorodne wymagania aplikacji.

5. Społeczność i wsparcie: Dzięki aktywnej społeczności programistów i kompleksowej dokumentacji, Autofac zapewnia doskonałe wsparcie i zasoby do nauki, rozwiązywania problemów i wnoszenia wkładu w framework.

Przedstawiamy IronPDF od Iron Software

IronPDF to solidna biblioteka PDF w języku C#, zaprojektowana w celu zapewnienia kompleksowego rozwiązania do zarządzania plikami PDF w projektach .NET. Niezależnie od tego, czy Twoje potrzeby dotyczą tworzenia, edycji, eksportowania, zabezpieczania, ładowania czy manipulowania dokumentami PDF, IronPDF ma narzędzia, których potrzebujesz. Oto kilka wyróżniających się funkcji i zastosowań:

• Dowiedz się więcej o tworzeniu plików PDF z IronPDF
• Odkryj, jak efektywnie edytować pliki PDF za pomocą IronPDF
• Poznaj funkcje zabezpieczeń IronPDF
• Odwiedź stronę Iron Software, aby uzyskać więcej informacji
• Zapoznaj się z dokumentacją IronPDF, aby uzyskać szczegółowe wskazówki

Generowanie dokumentu PDF przy użyciu Autofac.NET i IronPDF

Najpierw stwórzmy konsolową aplikację Visual Studio.

Podaj nazwę projektu i lokalizację.

W następnym kroku wybierz wymaganą wersję .NET i kliknij Utwórz.

Następnie zainstaluj bibliotekę IronPDF z menedżera pakietów NuGet w Visual Studio.

Odwiedź dokumentację IronPDF, aby uzyskać więcej informacji na temat instalacji i korzystania z biblioteki IronPDF.

Zainstaluj Autofac z menedżera pakietów NuGet w Visual Studio.

Dowiedz się więcej o Autofac, odwiedzając stronę dokumentacji 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

Licencja IronPDF

IronPDF wymaga klucza licencyjnego. Umieść klucz licencyjny w pliku appSettings.json, jak pokazano poniżej.

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