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. Dependency Injection (DI)-Container spielen eine entscheidende Rolle bei der Erreichung dieser Ziele, indem sie das Prinzip der Inversion of Control (IoC) unterstützen. 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.

Für weitere Informationen darüber, wie Autofac Ihre .NET-Anwendungen verbessert, sollten Sie die von der IronPDF .NET PDF Library bereitgestellten Ressourcen erkunden, die erweiterte Funktionen zur PDF-Erzeugung und -Manipulation hervorheben. Sie können auch in die .NET Barcode-Bibliothek von IronBarcode eintauchen, um praktische Anwendungen von Dependency Injection in der Barcode-Erzeugung zu sehen.

Erhalten Sie zusätzliche Einblicke und praktische Beispiele zur Verwendung von Autofac in realen Szenarien, indem Sie die offizielle Seite von IronSoftware besuchen, auf der Sie eine umfassende Produktsuite wie IronOCR und IronXL finden, die sich nahtlos in Autofac integrieren und Ihren .NET-Entwicklungsprozess verbessern.

Merkmale von Autofac

1. Containererstellung und Komponentenregistrierung: Sie können Container mithilfe von Autofac erstellen, indem Sie 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ängigkeitsinjektion: Autofac kann Konstruktorparameter injizieren, die Eigenschaftsinjektion und die Methodeninjektion handhaben.

    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 Modul-System: Autofac-Module stellen ein Gleichgewicht zwischen XML-Konfiguration und codebasierter Registrierung her. 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 zur Anpassung der Komponentenaktivierung oder -freigabe.

    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 Entwicklern, Komponenten mithilfe verschiedener Registrierungstechniken zu registrieren, einschließlich manueller Registrierung, Assembliescanning und attributbasierter Registrierung. Diese Flexibilität ermöglicht eine fein abgestufte Steuerung der Komponenteninstanziierung und -konfiguration.

2. Lebenszyklusverwaltung: Autofac unterstützt verschiedene Objektlebenszyklusbereiche, einschließlich Singleton, Instanz pro Abhängigkeit, Instanz pro Lebenszyklusbereich und Instanz pro Anfrage. Diese feingranulare Steuerung der Objektlebenszyklen gewährleistet eine effiziente Ressourcennutzung und verhindert Speicherlecks in langlaufenden Anwendungen.

3. Automatische Abhängigkeitsauflösung: Autofac löst automatisch Abhängigkeiten basierend auf den registrierten Komponentenregistrierungen und deren Abhängigkeiten auf. Diese automatische Verdrahtung vereinfacht die Konfiguration komplexer Objektgraphen und fördert die lose Kopplung zwischen Komponenten.

4. Modulzusammensetzung: 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 Abfangen und aspektorientierte Programmierung (AOP) durch seine Erweiterung zur Abfangung. 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 mit .NET Core und ASP.NET Core und bietet erstklassige Unterstützung für Dependency Injection in modernen Webanwendungen und Mikrodiensten. 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.

Für 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, besuchen Sie die IronPDF-Dokumentation, wo Sie lernen können, wie Sie PDF-Dokumente programmatisch erstellen und bearbeiten, oder besuchen Sie die Website von Iron Software, um eine breite Palette leistungsstarker .NET-Bibliotheken wie IronBarcode zum Lesen und Schreiben von Barcodes und IronOCR für fortschrittliche optische Zeichenerkennung zu entdecken.

Vorteile der Verwendung von Autofac.NET

1. Einfachheit und Flexibilität: Autofac bietet eine einfache und intuitive API zur Registrierung und Auflösung von Komponenten, sodass die Implementierung und Wartung von Dependency Injection erleichtert wird.

2. Testbarkeit und Wartbarkeit: Durch die Förderung von losem Kopplung und Abhängigkeitsinversion verbessert Autofac die Testbarkeit und Wartbarkeit von .NET-Anwendungen, wodurch Unit-Tests und Refaktorisierungen mit Leichtigkeit ermöglicht werden.

3. Leistung und Skalierbarkeit: Die leichte und effiziente Laufzeitleistung von Autofac macht es geeignet für Hochleistungsanwendungen und skalierbare Systeme mit großen Objektgraphen.

4. Erweiterbarkeit und Anpassung: Die erweiterbare Architektur von Autofac ermöglicht es Entwicklern, das Verhalten von Autofac durch benutzerdefinierte Module, Registrierungquellen und Middleware-Komponenten zu erweitern und anzupassen, um den unterschiedlichen Anforderungen von Anwendungen gerecht zu werden.

5. Community und Support: Mit einer aktiven Entwicklergemeinschaft und umfassender Dokumentation bietet Autofac hervorragenden Support und Ressourcen zum Lernen, zur Fehlerbehebung und zum Beitrag zum 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 effizient mit IronPDF bearbeiten können
• Erkunden Sie die Sicherheitsfunktionen von IronPDF
• Besuchen Sie die Iron Software-Website für weitere Details
• Schauen Sie sich die IronPDF-Dokumentation für ausführliche Anleitungen an

Wesentliche Merkmale

• HTML-zu-PDF-Konvertierung: HTML-Inhalte mühelos in PDF umwandeln. Generieren Sie PDFs aus HTML, MVC, ASPX und Bildern.
• PDF-Verwaltung: Mit über 50 Funktionen ermöglicht IronPDF das Signieren, Bearbeiten und Extrahieren von Inhalten aus PDFs, wodurch digitale Signaturen und Änderungen einfach werden.

• Plattformübergreifender Support: Kompatibel mit C#, F# und VB.NET, läuft IronPDF 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 die IronPDF-Produktseite.

  Für einen umfassenden Überblick über die Produktangebote von Iron Software, einschließlich IronBarcode, IronOCR und mehr, besuchen Sie die Iron Software-Homepage.

Kompatibilität und Umgebungen

• .NET-Versionen: Unterstützt C#, VB.NET und F#.
• Projekttypen: Geeignet für Web (Blazor & WebForms mit IronPDF), Desktop (WPF & MAUI) und Konsolenanwendungen.
• Anwendungsumgebungen: Kompatibel mit Windows, Linux, Mac, Docker, Azure, AWS und mehr.
• IDEs: Nahtlose Integration mit Microsoft Visual Studio und JetBrains Rider.
• Betriebssysteme & Prozessoren: Läuft auf 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 Kompression für PDF-Dateien fest.
• Metadaten und Struktur: Metadaten, Versionsverlauf und Dokumentstruktur bearbeiten.

• Vorlagen und Einstellungen: Wenden Sie Seitenvorlagen, Kopfzeilen, Fußzeilen und Seiteneinstellungen an.

  Weitere Informationen zu diesen Funktionen und deren Implementierung finden Sie im ausführlichen Leitfaden zur PDF-Erstellung und -Bearbeitung auf der offiziellen IronPDF-Website.

Optimierung der Leistung

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

• Priorität: Konzentriert sich 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 Sie IronPDF-Dokumentation, um weitere Informationen zur Installation und Nutzung der IronPDF-Bibliothek zu erhalten.

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

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

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 zur Erstellung von PDFs aus HTML-Inhalten, ein Schlüsselfeature von IronPDF.

2. Vorbereitung von HTML-Inhalten:

   • Die content-Variable ist eine HTML-Zeichenkette, die zur Erstellung des PDFs verwendet wird.

   • Es enthält ein <h1>-Tag mit dem Titel "Demonstrate Autofac with IronPDF".

3. Einrichten des Autofac-Containers:

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

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

4. Typen manuell registrieren:

   • Es registriert einen Typ MyService als eine Implementierung der IMyService-Schnittstelle.

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

5. Registrierung von Typen durch Assembly-Scanning:

   • Es scannt die Assembly, die den AutoFac-Typ enthält.

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

6. Module registrieren:

   • Es registriert ein Modul namens MyModule.

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

7. Erstellung des Containers:

   • Der Container wird aus den registrierten Komponenten mithilfe der Methode builder.Build() erstellt.

8. Abhängigkeitsauflösung:

   • Innerhalb eines Lebenszeitbereichs (using (var scope = container.BeginLifetimeScope())) wird eine Instanz von IMyService aufgelöst.

   • Die DoSomething-Methode wird auf dem aufgelösten Dienst aufgerufen.

9. PDF-Erstellung:

   • Ein PDF wird aus dem Inhalt mit dem ChromePdfRenderer 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"
}