Autofac .NET 6 (Wie es für Entwickler funktioniert)

Im Bereich der .NET-Entwicklung ist die effiziente Verwaltung von Abhängigkeiten entscheidend für die Erstellung skalierbarer, wartbarer und testbarer Anwendungen. Injektion von Abhängigkeiten (DI) container spielen eine zentrale Rolle bei der Erreichung dieser Ziele, da sie die Umkehrung der Kontrolle erleichtern (IoC) prinzip. Unter der Fülle der verfügbaren generischen Hosting-Mechanismus-Bibliotheken sticht Autofac als funktionsreiches und erweiterbares Framework für .NET hervor.

In diesem Artikel begeben wir uns auf eine Reise, um Autofac .NET 6 zu erkunden, seine Funktionen und Vorteile zu enträtseln und praktische Beispiele für seine Verwendung zu zeigen. Später in diesem Artikel werden wir IronPDF kennenlernen, eine PDF-Erzeugungsbibliothek von Iron Software. Wir werden auch einen Anwendungsfall vorstellen, bei dem Autofac.NET und IronPDF zusammen eingesetzt werden.

Verständnis von Autofac .NET

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

Merkmale von Autofac

1. Bau von Containern und Registrierung von Komponenten: Sie können mit Autofac Container bauen, indem Sie die Komponenten in der Startklasse registrieren. Sie können Komponenten mit Lambdas, Typen oder vorgefertigten Instanzen registrieren.

    public class Startup
    {
        public void ConfigureContainer()
        {
            var builder = new ContainerBuilder(); // host sub property builder
            builder.RegisterInstance(new TaskRepository()).As<ITaskRepository>();
            builder.RegisterType<TaskController>();
            builder.Register(c => new LogManager(DateTime.Now)).As<ILogger>();
            // Scan an assembly for components
            builder.RegisterAssemblyTypes(myAssembly).Where(t => t.Name.EndsWith("Repository")).AsImplementedInterfaces();
            var container = builder.Build();
        }
    }

    public class Startup
    {
        public void ConfigureContainer()
        {
            var builder = new ContainerBuilder(); // host sub property builder
            builder.RegisterInstance(new TaskRepository()).As<ITaskRepository>();
            builder.RegisterType<TaskController>();
            builder.Register(c => new LogManager(DateTime.Now)).As<ILogger>();
            // Scan an assembly for components
            builder.RegisterAssemblyTypes(myAssembly).Where(t => t.Name.EndsWith("Repository")).AsImplementedInterfaces();
            var container = builder.Build();
        }
    }

IRON VB CONVERTER ERROR developers@ironsoftware.com

2. Abhängigkeiten ausdrücken: Autofac kann Konstruktorparameter injizieren, Property Injection und Method Injection behandeln.

    public class TaskController
    {
        private ITaskRepository _repository;
        private ILogger _logger;

        public TaskController(ITaskRepository repository, ILogger logger)
        {
            this._repository = repository;
            this._logger = logger;
        }
    }

    public class TaskController
    {
        private ITaskRepository _repository;
        private ILogger _logger;

        public TaskController(ITaskRepository repository, ILogger logger)
        {
            this._repository = repository;
            this._logger = logger;
        }
    }

IRON VB CONVERTER ERROR developers@ironsoftware.com

3. Flexibles Modulsystem: Autofac-Module schaffen ein Gleichgewicht zwischen XML-Konfiguration und codebasierten Registrierungen. Sie können komplexe Registrierungen im Code angeben oder das Verhalten bei der Bereitstellung mithilfe von XML ändern.

    public class CarTransportModule : Module
    {
        public bool ObeySpeedLimit { get; set; }

        protected override void Load(ContainerBuilder builder)
        {
            builder.RegisterType<Car>().As<IVehicle>();
            if (ObeySpeedLimit)
                builder.RegisterType<SaneDriver>().As<IDriver>();
            else
                builder.RegisterType<CrazyDriver>().As<IDriver>();
        }
    }

    public class CarTransportModule : Module
    {
        public bool ObeySpeedLimit { get; set; }

        protected override void Load(ContainerBuilder builder)
        {
            builder.RegisterType<Car>().As<IVehicle>();
            if (ObeySpeedLimit)
                builder.RegisterType<SaneDriver>().As<IDriver>();
            else
                builder.RegisterType<CrazyDriver>().As<IDriver>();
        }
    }

IRON VB CONVERTER ERROR developers@ironsoftware.com

4. 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());
    builder.RegisterType<Processor>().OnActivating(e => e.Instance.Initialize());
    var container = builder.Build();

    var builder = new ContainerBuilder();
    builder.RegisterType<Listener>().As<IListener>().OnActivated(e => e.Instance.StartListening());
    builder.RegisterType<Processor>().OnActivating(e => e.Instance.Initialize());
    var container = builder.Build();

IRON VB CONVERTER ERROR developers@ironsoftware.com

Hauptmerkmale von Autofac.NET

1. Flexible Komponentenregistrierung: Autofac ermöglicht es Entwicklern, Komponenten mit einer Vielzahl von Registrierungstechniken zu registrieren, darunter manuelle Registrierung, Scannen von Baugruppen und attributbasierte Registrierung. Diese Flexibilität ermöglicht eine fein abgestufte Steuerung der Komponenteninstanziierung und -konfiguration.

2. Lebenszeit-Management: Autofac unterstützt verschiedene Objektlebenszeitbereiche, darunter Singleton, Instanz pro Abhängigkeit, Instanz pro Lebenszeitbereich und Instanz pro Anfrage. Diese granulare Steuerung der Objektlebensdauer gewährleistet eine effiziente Ressourcennutzung und verhindert Speicherlecks in lang laufenden Anwendungen.

3. Automatische Auflösung von Abhängigkeiten: Autofac löst Abhängigkeiten automatisch auf der Grundlage der registrierten Komponentenregistrierungen und ihrer Abhängigkeiten auf. Diese automatische Verdrahtung vereinfacht die Konfiguration komplexer Objektgraphen und fördert die lose Kopplung zwischen Komponenten.

4. Modul-Zusammensetzung: Autofac ermöglicht es Entwicklern, Komponentenregistrierungen mithilfe von Modulen zu organisieren und zu kapseln. Module dienen als logische Container für zusammenhängende Registrierungen und erleichtern die Verwaltung und Pflege umfangreicher Anwendungen mit mehreren Komponenten.

5. Abfangen und AOP: Autofac bietet Unterstützung für Interception und aspektorientierte Programmierung (AOP) durch seine Abfangverlängerung. Mit Interception können Entwickler übergreifende Aspekte wie Protokollierung, 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. Sie nutzt die eingebaute Abstraktion von Dienstanbietern, um Kompatibilität und Interoperabilität mit dem .NET-Ökosystem zu gewährleisten.

Praktische Beispiele mit Autofac.NET

Lassen Sie uns einige praktische Beispiele zur Veranschaulichung der Verwendung von Autofac.NET untersuchen:

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 die Injektion von Abhängigkeiten demonstriert. Von der manuellen Registrierung über das Scannen von Baugruppen bis hin zur modulbasierten Registrierung haben wir gezeigt, welche Flexibilität Autofac bei der Verwaltung von Abhängigkeiten bietet. Durch den Einsatz dieser Techniken können Entwickler den Prozess der Injektion von Abhängigkeiten in ihre Anwendungen optimieren und so die Wartbarkeit und Skalierbarkeit verbessern.

Vorteile der Verwendung von Autofac.NET

1. Einfachheit und Flexibilität: Autofac bietet eine einfache und intuitive API für die Registrierung und Auflösung von Komponenten, wodurch die Injektion von Abhängigkeiten einfach zu implementieren und zu pflegen ist.

2. Testbarkeit und Wartbarkeit: Durch die Förderung der losen Kopplung und der Umkehrung von Abhängigkeiten verbessert Autofac die Testbarkeit und Wartbarkeit von .NET-Anwendungen und ermöglicht Unit-Tests und Refactoring mit Leichtigkeit.

3. Leistung und Skalierbarkeit: Autofacs leichtgewichtige und effiziente Laufzeitleistung macht es für Hochleistungsanwendungen und skalierbare Systeme mit großen Objektgraphen geeignet.

4. Erweiterbarkeit und Anpassung: Die erweiterbare Architektur von Autofac ermöglicht es Entwicklern, das Verhalten von Autofac durch benutzerdefinierte Module, Registrierungsquellen und Middleware-Komponenten zu erweitern und anzupassen, um die unterschiedlichsten Anwendungsanforderungen zu erfüllen.

5. Gemeinschaft und Unterstützung: Mit einer aktiven Gemeinschaft von Entwicklern und einer umfassenden Dokumentation bietet Autofac hervorragende Unterstützung und Ressourcen für das Lernen, die Fehlerbehebung und die Mitarbeit am Framework.

Autofac-Lizenz

Autofac wird mit einer MIT-Lizenz ausgeliefert, die sowohl für die Entwicklung als auch für kommerzielle Zwecke frei verwendbar ist.

Einführung in IronPDF von Iron Software

IronPDF ist eine robuste C# PDF-Bibliothek, die eine umfassende Lösung für die Verwaltung von PDFs in .NET-Projekten bietet. Egal, ob Sie PDF-Dokumente erstellen, bearbeiten, exportieren, sichern, laden oder manipulieren möchten, IronPDF hat die Werkzeuge, die Sie brauchen. Hier sind einige seiner herausragenden Funktionen und Anwendungen:

Wesentliche Merkmale

• HTML zu PDF Konvertierung: Konvertieren Sie mühelos HTML-Inhalte in PDF. Generieren Sie PDFs aus HTML, MVC, ASPX und Bildern.
• PDF-Verwaltung: Mit mehr als 50 Funktionen ermöglicht IronPDF das Signieren, Bearbeiten und Extrahieren von Inhalten aus PDFs und erleichtert so digitale Signaturen und Änderungen.
• Plattformübergreifende Unterstützung: IronPDF ist kompatibel mit C#, F# und VB.NET und läuft auf verschiedenen .NET-Versionen, einschließlich .NET Core, .NET Standard und .NET Framework. Es ist auch für Java, Node.js und Python verfügbar.

Kompatibilität und Umgebungen

• .NET-Versionen: Unterstützt C#, VB.NET und F#.
• Projekttypen: Geeignet für Web (Blazor und WebForms)schreibtisch (WPF UND MAUI)und Konsolenanwendungen.
• App-Umgebungen: Kompatibel mit Windows, Linux, Mac, Docker, Azure, AWS und mehr.
• IDEs: Nahtlose Integration mit Microsoft Visual Studio und JetBrains Rider.
• OS & Prozessoren: Funktioniert unter Windows, Mac und Linux (x64, x86, ARM).

PDF-Standards und -Bearbeitung

• Kompatibilität: Unterstützt verschiedene PDF-Versionen (1.2 - 1.7), PDF/UA, und PDF/A.
• Anpassung: Legen Sie Eigenschaften, Sicherheit und Komprimierung für PDF-Dateien fest.
• Metadaten und Struktur: Bearbeiten Sie Metadaten, den Änderungsverlauf und die Dokumentstruktur.
• Vorlagen und Einstellungen: Anwenden von Seitenvorlagen, Kopf- und Fußzeilen und Seiteneinstellungen.

Optimierung der Leistung

• Effizienz: Volle Multithreading- und Async-Unterstützung für effiziente PDF-Erstellung.

• Priorität: Der Schwerpunkt liegt auf Genauigkeit, Benutzerfreundlichkeit und Geschwindigkeit.

  Schauen wir uns nun ein praktisches Beispiel mit diesen beiden Bibliotheken an.

Erzeugen von PDF-Dokumenten mit Autofac.NET und IronPDF

Erstellen wir zunächst eine Visual Studio-Konsolenanwendung

Geben Sie den Namen und den Standort des Projekts an.

Im nächsten Schritt wählen Sie die gewünschte .NET-Version aus und klicken auf Erstellen.

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

Installieren Sie Autofac über das NuGet-Paket aus dem Visual Studio Package Manager

Code-Beispiel: Autofac und IronPDF

using Autofac;
using CacheManager.Core;
using IronPdf;
using System.Reflection;

namespace IronPdfDemos
{
    public class AutoFac
    {
        public static void Execute()
        {
            // Instantiate Cache and ChromePdfRenderer
            var renderer = new ChromePdfRenderer();
            var cache = CacheFactory.Build("ironPdfAutofac", settings =>
            {
                settings.WithDictionaryHandle();
            });

            // Prepare HTML content
            var content = "<h1>Demonstrate Autofac with IronPDF</h1>";
            content += "<p>This is an illustration of using Autofac for dependency injection and IronPDF for generating PDF documents.</p>";
            content += "<h2>Setting up Autofac container</h2>";

            // Setting up Autofac container
            var builder = new ContainerBuilder();
            content += "<p>var builder = new ContainerBuilder();</p>";

            content += "<h2>Registering types manually</h2>";
            // Registering types manually
            builder.RegisterType<MyService>().As<IMyService>();
            content += "<p>builder.RegisterType<MyService>().As<IMyService();</p>";

            content += "<h2>Registering types using assembly scanning</h2>";
            // Registering types using assembly scanning
            builder.RegisterAssemblyTypes(typeof(AutoFac).Assembly)
                .Where(t => t.Name.EndsWith("Repository"))
                .AsImplementedInterfaces();
            content += "<p>builder.RegisterAssemblyTypes(typeof(AutoFac).Assembly).Where(t => t.Name.EndsWith(\"Repository\")).AsImplementedInterfaces();</p>";

            content += "<h2>Registering modules</h2>";
            // Registering modules
            builder.RegisterModule(new MyModule());
            content += "<p>builder.RegisterModule(new MyModule());</p>";

            content += "<h2>Building the container</h2>";
            // Building the container
            var container = builder.Build();
            content += "<p>var container = builder.Build();</p>";

            content += "<h2>Resolving dependencies</h2>";
            // Resolving dependencies
            using (var scope = container.BeginLifetimeScope())
            {
                var service = scope.Resolve<IMyService>();
                service.DoSomething();
            }
            content += "<p>var service = scope.Resolve<IMyService();</p>";

            // Create a PDF from the HTML string using C#
            var pdf = renderer.RenderHtmlAsPdf(content);
            // Export to a file or Stream
            pdf.SaveAs("autofac.pdf");
            Console.WriteLine("We are done...");
            Console.ReadKey();
        }
    }

    internal interface IMyService
    {
        void DoSomething();
    }

    internal class MyModule : Module
    {
        protected override void Load(ContainerBuilder builder)
        {
            // Register module dependencies here
        }
    }

    internal class MyService : IMyService
    {
        public void DoSomething()
        {
            Console.WriteLine("DoSomething");
        }
    }
}

using Autofac;
using CacheManager.Core;
using IronPdf;
using System.Reflection;

namespace IronPdfDemos
{
    public class AutoFac
    {
        public static void Execute()
        {
            // Instantiate Cache and ChromePdfRenderer
            var renderer = new ChromePdfRenderer();
            var cache = CacheFactory.Build("ironPdfAutofac", settings =>
            {
                settings.WithDictionaryHandle();
            });

            // Prepare HTML content
            var content = "<h1>Demonstrate Autofac with IronPDF</h1>";
            content += "<p>This is an illustration of using Autofac for dependency injection and IronPDF for generating PDF documents.</p>";
            content += "<h2>Setting up Autofac container</h2>";

            // Setting up Autofac container
            var builder = new ContainerBuilder();
            content += "<p>var builder = new ContainerBuilder();</p>";

            content += "<h2>Registering types manually</h2>";
            // Registering types manually
            builder.RegisterType<MyService>().As<IMyService>();
            content += "<p>builder.RegisterType<MyService>().As<IMyService();</p>";

            content += "<h2>Registering types using assembly scanning</h2>";
            // Registering types using assembly scanning
            builder.RegisterAssemblyTypes(typeof(AutoFac).Assembly)
                .Where(t => t.Name.EndsWith("Repository"))
                .AsImplementedInterfaces();
            content += "<p>builder.RegisterAssemblyTypes(typeof(AutoFac).Assembly).Where(t => t.Name.EndsWith(\"Repository\")).AsImplementedInterfaces();</p>";

            content += "<h2>Registering modules</h2>";
            // Registering modules
            builder.RegisterModule(new MyModule());
            content += "<p>builder.RegisterModule(new MyModule());</p>";

            content += "<h2>Building the container</h2>";
            // Building the container
            var container = builder.Build();
            content += "<p>var container = builder.Build();</p>";

            content += "<h2>Resolving dependencies</h2>";
            // Resolving dependencies
            using (var scope = container.BeginLifetimeScope())
            {
                var service = scope.Resolve<IMyService>();
                service.DoSomething();
            }
            content += "<p>var service = scope.Resolve<IMyService();</p>";

            // Create a PDF from the HTML string using C#
            var pdf = renderer.RenderHtmlAsPdf(content);
            // Export to a file or Stream
            pdf.SaveAs("autofac.pdf");
            Console.WriteLine("We are done...");
            Console.ReadKey();
        }
    }

    internal interface IMyService
    {
        void DoSomething();
    }

    internal class MyModule : Module
    {
        protected override void Load(ContainerBuilder builder)
        {
            // Register module dependencies here
        }
    }

    internal class MyService : IMyService
    {
        public void DoSomething()
        {
            Console.WriteLine("DoSomething");
        }
    }
}

Imports Autofac
Imports CacheManager.Core
Imports IronPdf
Imports System.Reflection

Namespace IronPdfDemos
	Public Class AutoFac
		Public Shared Sub Execute()
			' Instantiate Cache and ChromePdfRenderer
			Dim renderer = New ChromePdfRenderer()
			Dim cache = CacheFactory.Build("ironPdfAutofac", Sub(settings)
				settings.WithDictionaryHandle()
			End Sub)

			' Prepare HTML content
			Dim content = "<h1>Demonstrate Autofac with IronPDF</h1>"
			content &= "<p>This is an illustration of using Autofac for dependency injection and IronPDF for generating PDF documents.</p>"
			content &= "<h2>Setting up Autofac container</h2>"

			' Setting up Autofac container
			Dim builder = New ContainerBuilder()
			content &= "<p>var builder = new ContainerBuilder();</p>"

			content &= "<h2>Registering types manually</h2>"
			' Registering types manually
			builder.RegisterType(Of MyService)().As(Of IMyService)()
			content &= "<p>builder.RegisterType<MyService>().As<IMyService();</p>"

			content &= "<h2>Registering types using assembly scanning</h2>"
			' Registering types using assembly scanning
			builder.RegisterAssemblyTypes(GetType(AutoFac).Assembly).Where(Function(t) t.Name.EndsWith("Repository")).AsImplementedInterfaces()
			content &= "<p>builder.RegisterAssemblyTypes(typeof(AutoFac).Assembly).Where(t => t.Name.EndsWith(""Repository"")).AsImplementedInterfaces();</p>"

			content &= "<h2>Registering modules</h2>"
			' Registering modules
			builder.RegisterModule(New MyModule())
			content &= "<p>builder.RegisterModule(new MyModule());</p>"

			content &= "<h2>Building the container</h2>"
			' Building the container
			Dim container = builder.Build()
			content &= "<p>var container = builder.Build();</p>"

			content &= "<h2>Resolving dependencies</h2>"
			' Resolving dependencies
			Using scope = container.BeginLifetimeScope()
				Dim service = scope.Resolve(Of IMyService)()
				service.DoSomething()
			End Using
			content &= "<p>var service = scope.Resolve<IMyService();</p>"

			' Create a PDF from the HTML string using C#
			Dim pdf = renderer.RenderHtmlAsPdf(content)
			' Export to a file or Stream
			pdf.SaveAs("autofac.pdf")
			Console.WriteLine("We are done...")
			Console.ReadKey()
		End Sub
	End Class

	Friend Interface IMyService
		Sub DoSomething()
	End Interface

	Friend Class MyModule
		Inherits Module

		Protected Overrides Sub Load(ByVal builder As ContainerBuilder)
			' Register module dependencies here
		End Sub
	End Class

	Friend Class MyService
		Implements IMyService

		Public Sub DoSomething() Implements IMyService.DoSomething
			Console.WriteLine("DoSomething")
		End Sub
	End Class
End Namespace

Code Erläuterung

Lassen Sie uns den von Ihnen bereitgestellten Codeschnipsel aufschlüsseln:

1. ChromePdfRenderer Setup:

   • Der Code initialisiert eine ChromePdfRenderer-Instanz zum Rendern von PDFs.

2. HTML-Inhaltsvorbereitung:

   • Die Variable "Inhalt" ist eine HTML-Zeichenfolge, die zur Erstellung der PDF-Datei verwendet wird.

   • Er enthält einen <h1>-Tag mit dem Titel "Demonstration von Autofac mit IronPDF".

3. Einrichten des Autofac-Containers:

   • Der Code erzeugt eine Instanz von ContainerBuilder mit dem Namen builder.

   • Dies ist der erste Schritt beim Einrichten eines Autofac-Containers für Dependency Injection.

4. Manuelle Registrierung von Typen:

   • Sie registriert einen Typ MyService als Implementierung der Schnittstelle IMyService.

   • Dies ermöglicht es Autofac, Abhängigkeiten bei Bedarf aufzulösen.

5. Registrierung von Typen mit Hilfe von Assembly Scanning:

   • Sie durchsucht die Baugruppe, die den Typ "AutoFac" enthält.

   • Registriert Typen, deren Namen mit "Repository" enden, als Implementierungen ihrer entsprechenden Schnittstellen.

6. Registrierung von Modulen:

   • Es registriert ein Modul mit dem Namen MeinModul.

   • Module ermöglichen die Gruppierung zusammengehöriger Registrierungen.

7. Bau des Containers:

   • Der Container wird aus den registrierten Komponenten mit der Funktion `builder.Build()methode.

8. Auflösen von Abhängigkeiten:

   • Innerhalb eines lebenslangen Geltungsbereichs (verwendung (var scope = container.BeginLifetimeScope())`)löst er eine Instanz von "IMyService" auf.

   • Die Methode DoSomething wird für den aufgelösten Dienst aufgerufen.

9. PDF-Erstellung:

   • Aus dem Inhalt wird mit dem ChromePdfRenderer ein PDF erstellt.

   • Die resultierende PDF-Datei wird als "autofac.pdf" gespeichert.

Ausgabe

IronPDF-Lizenz

IronPDF benötigt einen Lizenzschlüssel. Platzieren Sie den Lizenzschlüssel in der Datei "appSettings.json" wie unten gezeigt.

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

Schlussfolgerung

Zusammenfassend lässt sich sagen, dass Autofac.NET ein robuster und funktionsreicher Dependency Injection Container für .NET ist, der es Entwicklern ermöglicht, modulare, wartbare und erweiterbare Anwendungen zu erstellen. Ganz gleich, ob Sie Desktop-Anwendungen, Webdienste oder Cloud-native Lösungen entwickeln, Autofac bietet eine zuverlässige Grundlage für die Verwaltung von Abhängigkeiten und die Förderung von Best Practices in der .NET-Entwicklung.

IronPDF ist eine vielseitige und funktionsreiche Bibliothek zum Erzeugen, Bearbeiten und Lesen von PDF-Dokumenten. Zusammen mit der IronPDF-Bibliothek von Iron Software zum Lesen und Erzeugen von PDF-Dokumenten können Entwickler fortgeschrittene Fähigkeiten zur Entwicklung moderner Anwendungen erwerben.