Autofac .NET 6 (Funktionsweise für Entwickler)

Autofac .NET verstehen

Autofac ist ein Open-Source-IoC-Container für .NET, der umfassende Unterstützung für Dependency Injection und Komponentenregistrierung in Apps wie Web-APIs bietet. Entwickelt von Nicholas Blumhardt und gepflegt von einer engagierten Community, bietet Autofac eine robuste und flexible Lösung für das Management von Objektlebensdauern, die Lösung von Abhängigkeiten und die Komposition von Anwendungskomponenten.

Für weitere Informationen darüber, wie Autofac Ihre .NET-Anwendungen verbessert, sollten Sie die Ressourcen von IronPDF's .NET PDF Library erkunden, die erweiterte Funktionen für die PDF-Erstellung und -Bearbeitung hervorhebt. Sie können auch in die IronBarcode's .NET Barcode Library eintauchen, um praktische Anwendungen von Dependency Injection in der Barcodelerzeugung zu sehen.

Lassen Sie sich durch zusätzliche Einblicke und praktische Beispiele zur Nutzung von Autofac in realen Szenarien inspirieren, indem Sie die offizielle Seite von Iron Software besuchen, wo Sie eine umfassende Produktreihe wie IronOCR und IronXL finden, die sich nahtlos mit Autofac integrieren und Ihren .NET-Entwicklungsprozess verbessern.

Funktionen von Autofac

1. Container-Erstellung und Komponentenregistrierung: Sie können Container mit Autofac erstellen, indem Sie Komponenten in der Startup-Klasse registrieren. Sie können Komponenten mit Lambdas, Typen oder vorgefertigten Instanzen registrieren.

   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. Express-Abhängigkeiten: Autofac kann Konstruktorparameter einfügen, Eigenschaften injizieren und Methoden injizieren.

   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. Flexibles Modulsystem: Autofac-Module schaffen ein Gleichgewicht zwischen XML-Konfiguration und codebasierter Registrierung. Sie können komplexe Registrierungen im Code festlegen oder das Verhalten zur Bereitstellungszeit mithilfe von XML ändern.

   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. Einfache Erweiterungspunkte: Autofac bietet Aktivierungsereignisse, um die Aktivierung oder Freigabe von Komponenten anzupassen.

   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

Schlüsselmerkmale von Autofac.NET

1. Flexible Komponentenregistrierung: Autofac ermöglicht es Entwicklern, Komponenten mithilfe verschiedener Registrierungstechniken zu registrieren, darunter manuelle Registrierung, Assembly-Scanning und attributbasierte Registrierung. Diese Flexibilität ermöglicht eine feinkörnige Kontrolle über die Instanziierung und Konfiguration von Komponenten.

2. Lebenszyklusmanagement: Autofac unterstützt verschiedene Objektlebenszyklusbereiche, darunter Singleton, Instanz pro Abhängigkeit, Instanz pro Lebenszyklusbereich und Instanz pro Anfrage. Diese detaillierte Kontrolle über die Objektlebensdauer gewährleistet eine effiziente Ressourcennutzung und verhindert Speicherlecks in langlaufenden Anwendungen.

3. Automatische Abhängigkeitsauflösung: Autofac löst Abhängigkeiten automatisch auf Basis der registrierten Komponentenregistrierungen und ihrer Abhängigkeiten auf. Diese automatische Verkabelung vereinfacht die Konfiguration komplexer Objektgrafen und fördert die lose Kopplung zwischen Komponenten.

4. Modulkomposition: Autofac ermöglicht es Entwicklern, Komponentenregistrierungen mithilfe von Modulen zu organisieren und zu kapseln. Module dienen als logische Container für verwandte Registrierungen, die das Management und die Wartung von großangelegten Anwendungen mit mehreren Komponenten erleichtern.

5. Interception und AOP: Autofac bietet Unterstützung für Interception und aspektorientierte Programmierung (AOP) durch seine Interception-Erweiterung. Mit Interception können Entwickler Querschnittsbedenken wie Logging, Caching und Sicherheit auf Komponenten anwenden, ohne deren Implementierung zu ändern.

6. ASP.NET Core und .NET Core Integration: Autofac integriert sich nahtlos in .NET Core und ASP.NET Core und bietet erstklassige Unterstützung für Dependency Injection in modernen Webanwendungen und Microservices. Es nutzt die integrierte Dienstanbieterabstraktion, um Kompatibilität und Interoperabilität mit dem .NET-Ökosystem sicherzustellen.

Praktische Beispiele mit Autofac.NET

Lassen Sie uns einige praktische Beispiele erkunden, um die Verwendung von Autofac.NET zu veranschaulichen:

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

In diesem Abschnitt haben wir die praktische Implementierung von Autofac.NET für Dependency Injection demonstriert. Von der manuellen Registrierung bis hin zum Assembliescanning und der modulbasierten Registrierung haben wir gezeigt, welche Flexibilität Autofac beim Management von Abhängigkeiten bietet. Durch die Nutzung dieser Techniken können Entwickler den Dependency Injection-Prozess ihrer Anwendung rationalisieren und die Wartbarkeit und Skalierbarkeit erhöhen.

Für weitere Informationen darüber, wie Iron Software-Produkte in Ihre .NET-Anwendungen integriert werden können, um die Funktionalität weiter zu rationalisieren und zu verbessern, besuchen Sie die IronPDF-Dokumentation, wo Sie lernen können, wie man PDF-Dokumente programmgesteuert generiert und bearbeitet, oder besuchen Sie die Iron Software-Website, um eine breite Palette leistungsstarker .NET-Bibliotheken zu entdecken, wie IronBarcode zum Lesen und Schreiben von Barcodes und IronOCR für fortschrittliche optische Zeichenverarbeitung.

Vorteile der Verwendung von Autofac.NET

1. Einfachheit und Flexibilität: Autofac bietet eine einfache und intuitive API zum Registrieren und Auflösen von Komponenten, wodurch die Abhängigkeitsinjektion einfach zu implementieren und zu warten ist.

2. Testbarkeit und Wartbarkeit: Durch die Förderung loser Kopplung und Abhängigkeitsumkehr verbessert Autofac die Testbarkeit und Wartbarkeit von .NET Anwendungen und ermöglicht so problemlos Unit-Tests und Refactoring.

3. Leistung und Skalierbarkeit: Dank seiner geringen Größe und hohen Laufzeitleistung eignet sich Autofac für leistungsstarke Anwendungen und skalierbare Systeme mit großen Objektgraphen.

4. Erweiterbarkeit und Anpassbarkeit: Die erweiterbare Architektur von Autofac ermöglicht es Entwicklern, das Verhalten von Autofac durch benutzerdefinierte Module, Registrierungsquellen und Middleware-Komponenten zu erweitern und anzupassen und so den vielfältigen Anwendungsanforderungen gerecht zu werden.

5. Community und Support: Mit einer aktiven Entwicklergemeinschaft und einer umfassenden Dokumentation bietet Autofac hervorragenden Support und Ressourcen zum Erlernen, zur Fehlerbehebung und zur Weiterentwicklung des Frameworks.

Einführung in IronPDF von Iron Software

IronPDF ist eine robuste C#-PDF-Bibliothek, die eine umfassende Lösung zur Verwaltung von PDFs in .NET-Projekten bietet. Ob Ihre Anforderungen die Erstellung, Bearbeitung, den Export, die Sicherung, das Laden oder die Manipulation von PDF-Dokumenten betreffen, IronPDF bietet die benötigten Werkzeuge. Hier sind einige seiner herausragenden Funktionen und Anwendungen:

• Erfahren Sie mehr über das Erstellen von PDFs mit IronPDF
• Entdecken Sie, wie man PDFs effizient mit IronPDF bearbeitet
• Erkunden Sie die Sicherheitsmerkmale von IronPDF
• Besuchen Sie die Iron Software-Website für weitere Details
• Schauen Sie sich die IronPDF-Dokumentation für detaillierte Anleitungen an

PDF-Dokument mit Autofac.NET und IronPDF generieren

Zuerst erstellen wir eine Visual Studio-Konsolenanwendung

Geben Sie den Projektnamen und den Speicherort an.

Für den nächsten Schritt wählen Sie die erforderliche .NET-Version aus und klicken Sie auf Erstellen.

Installieren Sie dann die IronPDF-Bibliothek aus dem NuGet-Paket im Visual Studio Package Manager

Besuchen Sie die IronPDF-Dokumentation für weitere Informationen zur Installation und Nutzung der IronPDF-Bibliothek.

Installieren Sie Autofac aus dem NuGet-Paket im Visual Studio Package Manager

Erfahren Sie mehr über Autofac, indem Sie die Autofac-Dokumentationsseite besuchen.

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

IronPDF-Lizenz

IronPDF benötigt einen Lizenzschlüssel. Fügen Sie den Lizenzschlüssel wie unten gezeigt in die Datei appSettings.json ein.

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