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.

Skorzystaj z dodatkowych informacji i praktycznych przykladow uzycia Autofac w rzeczywistych przypadkach przechodzac na oficjalna strone Iron Software, gdzie znajdziesz kompletny zestaw produktow jak IronOCR i IronXL, ktore integruja sie bezproblemowo z Autofac i wzbogacaja proces tworzenia w .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 konstruktóra, 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 cechy Autofac.NET

1. Elastyczna rejestracja komponentow: Autofac pozwala deweloperom rejestrowac komponenty uzywajac roznych technik rejestracji, w tym recznej rejestracji, skanowania poziomow, oraz rejestracji opartej na atrybutach. Ta elastycznosc pozwala na drobiazgowa kontrole nad tworzeniem i konfiguracja komponentow.

2. Zarzadzanie zywotnoscia: Autofac wspiera rozne zakresy zywotnosci obiektow, w tym singleton, instancja na zaleznosc, instancja na zakres zywotnosci oraz instancja na zapytanie. Ta szczegolowa kontrola nad zywotnoscia obiektow zapewnia efektywne uzycie zasobow i zapobiega wyciekom pamieci w dlugo dzialajacych aplikacjach.

3. Automatyczne rozwiazywanie zaleznosci: Autofac automatycznie rozwiazuje zaleznosci na podstawie zarejestrowanych rejestracji komponentow oraz ich zaleznosci. To automatyczne przewijanie upraszcza konfiguracje zlozonych grafow obiektow i promuje luźne powiązania między komponentami.

4. Kompozycja modułów: Autofac pozwala deweloperom organizowac i kapsulowac rejestracje komponentow za pomoca modulu. Moduly sluza jako logiczne kontenery dla powiazanych rejestracji, co ułatwia zarządzanie i utrzymywanie dużych aplikacji z wieloma komponentami.

5. Interception i AOP: Autofac wspiera interception i programowanie zorientowane na aspekty (AOP) dzięki swojej rozszerzonej funkcjonalności. Dzięki intercepcji, deweloperzy mogą stosować koncerny przeciwdziałające, takie jak logowanie, buforowanie i bezpieczeństwo do komponentów bez modyfikacji ich implementacji.

6. Integracja z ASP.NET Core i .NET Core: Autofac bezproblemowo integruje się z .NET Core i ASP.NET Core, oferując pierwszorzędne wsparcie dla wstrzykiwania zależności we współczesnych aplikacjach webowych i mikrousługach. Wykorzystuje wbudowany widok dostawcy usług do zapewnienia kompatybilności i interoperacyjności z ekosystemem .NET.

Praktyczne przyklady z Autofac.NET

Zbadajmy kilka praktycznych przykladow, aby zilustrowac zastosowanie 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 przedstawiliśmy praktyczną implementację Autofac.NET dla wstrzykiwania zależności. Od rejestracji manualnej po skanowanie poziomów i rejestracji bazującej na module, pokazaliśmy elastyczność Autofac w zarządzaniu zależnościami. Wykorzystując te techniki, deweloperzy mogą usprawnić proces wstrzykiwania zależności w swoich aplikacjach, zwiększając ich konserwację i skalowalność.

Więcej informacji na temat tego, jak produkty Iron Software mogą zintegrować się z aplikacjami .NET, aby dalej usprawnić i rozszerzyć funkcjonalność, znajdziesz w dokumentacji IronPDF, gdzie dowiesz się, jak generować i edytować dokumenty PDF programowo, lub odwiedzasz stronę internetową Iron Software, aby odkryć szeroki wachlarz potężnych bibliotek .NET, takich jak IronBarcode do odczytywania i pisania kodów kreskowych, oraz IronOCR do zaawansowanego rozpoznawania optycznego znaków.

Zalety używania Autofac.NET

1. Prostota i elastyczność: Autofac oferuje prosty i intuicyjny interfejs API do rejestrowania i rozwiązywania komponentów, co czyni wstrzykiwanie zależności łatwym do implementacji i konserwacji.

2. Testowanie i utrzymywanie: Poprzez promowanie luźnego powiązania i inwersji zależności, Autofac zwiększa testowalność i utrzymanie aplikacji .NET, umożliwiając łatwe testowanie jednostek i refaktorowanie.

3. Wydajność i skalowalność: Lekka i wydajna wydajność czasu działania Autofac sprawia, że jest ona odpowiednia dla aplikacji o wysokiej wydajności i skalowalnych systemów z dużymi drzewiastymi obiektami.

4. Rozszerzalność i personalizacja: Rozszerzalna architektura Autofac pozwala deweloperom rozszerzać i dostosowywać zachowanie Autofac poprzez własne moduły, źródła rejestracji i komponenty pośredniczące, spełniając różnorodne wymagania aplikacji.

5. Społeczność i wsparcie: Dzieki aktywnej społeczności deweloperów i szczegółowej dokumentacji, Autofac oferuje doskonałe wsparcie i zasoby do nauki, rozwiązywania problemów i przyczyniania się do ramek.

Przedstawienie IronPDF od Iron Software

IronPDF jest solidną biblioteką PDF dla C#, zaprojektowaną, aby zapewnić kompleksowe rozwiązanie do zarządzania PDF w projektach .NET. Niezależnie od Twoich potrzeb, które obejmują tworzenie, edytowanie, eksportowanie, zabezpieczanie, ładowanie lub manipulowanie dokumentami PDF, IronPDF ma narzędzia, których potrzebujesz. Oto niektóre z jego wyróżniających się funkcji i zastosowań:

• Dowiedz się więcej o tworzeniu PDF za pomocą IronPDF
• Odkryj, jak edytować PDF-y wydajnie z IronPDF
• Zbadaj funkcje bezpieczeństwa IronPDF
• Odwiedź stronę internetową Iron Software, aby uzyskać więcej szczegółów
• Sprawdź dokumentację IronPDF, aby uzyskać szczegółowe wskazówki

Generowanie dokumentu PDF za pomocą Autofac.NET i IronPDF

Na początek, stwórzmy aplikację konsolową Visual Studio

Podaj nazwę projektu i lokalizację.

Na następnym etapie, wybierz wymaganą wersję .NET i kliknij Utwórz.

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

Odwiedź Dokumentację IronPDF, aby uzyskać szczegółowe informacje na temat instalacji i korzystania z biblioteki IronPDF.

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

Dowiedz się więcej o Autofac, przechodząc na Stronę z dokumentacją 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"
}