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 leistungsstarke PDF-Erzeugungsbibliothek von Iron Software. Wir werden auch einen Anwendungsfall vorstellen, bei dem Autofac.NET und IronPDF zusammen eingesetzt werden.

Verstehen 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.

Weitere Informationen darüber, wie Autofac Ihre .NET-Anwendungen verbessert, finden Sie in den Ressourcen vonIronPDF's .NET PDF-Bibliothekdie Übersetzung soll die fortgeschrittenen Funktionen zur PDF-Erzeugung und -Bearbeitung hervorheben. Sie können sich auch mit folgenden Themen befassenIronBarcode's .NET Barcode Bibliothek um praktische Anwendungen von Dependency Injection in der Barcode-Generierung zu sehen.

Weitere Einblicke und praktische Beispiele für den Einsatz von Autofac in realen Szenarien finden Sie unterDie offizielle Seite von IronSoftwarehier finden Sie eine umfassende Suite von Produkten wie IronOCR und IronXL, die sich nahtlos in Autofac integrieren lassen und Ihren .NET-Entwicklungsprozess verbessern.

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.

Weitere Informationen darüber, wie die Produkte von Iron Software in Ihre .NET-Anwendungen integriert werden können, um die Funktionalität weiter zu optimieren und zu verbessern, finden Sie auf derIronPDF-Dokumentation wo Sie lernen können, wie man PDF-Dokumente programmatisch erzeugt und bearbeitet, oder besuchen SieWebsite von Iron Software um eine breite Palette von leistungsstarken .NET-Bibliotheken wie IronBarcode zum Lesen und Schreiben von Barcodes und IronOCR für die erweiterte optische Zeichenerkennung zu entdecken.

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:

• Erfahren Sie mehr über die Erstellung von PDFs mit IronPDF
• Entdecken Sie, wie Sie PDFs mit IronPDF effizient bearbeiten können
• Erkunden Sie die Sicherheitsfunktionen von IronPDF
• Besuchen Sie die Website von Iron Software für weitere Informationen
• Eine ausführliche Anleitung finden Sie in der IronPDF-Dokumentation

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.

  Um mehr darüber zu erfahren, wie IronPDF PDF-Funktionen in Ihre Projekte integrieren kann, besuchen Sie dieIronPDF Produktseite.

  Einen umfassenden Überblick über das Produktangebot von Iron Software, einschließlich IronBarcode, IronOCR und mehr, finden Sie auf der WebsiteIron Software Startseite.

Kompatibilität und Umgebungen

• .NET-Versionen: Unterstützt C#, VB.NET und F#.
• Projekttypen: Geeignet für Web(Blazor & WebForms mit IronPDF)schreibtisch(WPF UND MAUI)und Konsolenanwendungen.
• App-Umgebungen: Kompatibel mit Windows, Linux, Mac, Docker, Azure, AWS und mehr.
• IDEs: Nahtlos integrierbar mitMicrosoft Visual Studio undJetBrains-Reiter.
• 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.

  Weitere Informationen zu diesen Funktionen und deren Implementierung finden Sie auf der Websiteausführliche Anleitung zur PDF-Erzeugung und -Bearbeitung auf der offiziellen Website von IronPDF.

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

Besuchen SieIronPDF-Dokumentation weitere Informationen zur Installation und Nutzung der IronPDF-Bibliothek finden Sie hier.

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

Weitere Informationen über Autofac finden Sie auf derAutofac-Dokumentationsseite.

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 aus HTML-Inhalten, einer Schlüsselfunktion vonIronPDF.

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"
}