Microsoft.Extensions.DependencyInjection ist eine leistungsstarke Bibliothek von Microsoft .NET, die die Dependency Injection (DI) erleichtert, ein Software-Entwurfsmuster, das lockere Kopplung fördert und die Testbarkeit von Anwendungen verbessert. DI wird häufig mithilfe des eingebauten DI-Containers von .NET Core oder Bibliotheken wie Autofac und Unity implementiert. DI beinhaltet das Injizieren von Abhängigkeiten (Objekte, die eine Klasse benötigt) in eine Klasse, anstatt dass die Klasse ihre Abhängigkeiten erstellt. Dies geschieht typischerweise durch Konstruktor-, Methoden- oder Eigenschafteninjektion.

Abhängigkeits-Injektions-Container

1. Service Registrierung: Abhängigkeiten werden in einem DI-Container registriert, typischerweise an der Kompositionswurzel der Anwendung. Diese Registrierungen geben an, wie der Container die Abhängigkeiten erstellen und verwalten soll.

2. Dependency Auflösung: Wenn eine Komponente eine Abhängigkeit anfordert, löst der DI-Container die Abhängigkeit, indem er eine Instanz eines registrierten Typs erstellt, der eine Erweiterungsmethode verwendet.

Arten der Dependency Injection

• Konstruktorinjektion: Registrierte Dienste werden einer Klasse über ihren Konstruktor bereitgestellt, was die häufigste und empfohlene Form der DI ist.
• Methodeninjektion: Dienste werden aufgelöst und als Parameter an eine Methode übergeben.
• Eigenschafteninjektion: Singleton-Dienste oder Dienste mit einer festgelegten Lebenszeit können Klasseneigenschaften zugewiesen werden. Diese Vorgehensweise ist jedoch weniger verbreitet und wird oft als weniger wertig im Vergleich zur Konstruktorinjektion angesehen, da sie versteckte Abhängigkeiten einführen kann.

Verständnis von Lebensdauern in Dependency Injection (DI): Scoped, Transient, und Singleton

1. Gescoped: Gescopte Abhängigkeiten werden einmal pro Anfrage oder Lebensdauerbereich erstellt, was bedeutet, dass der Container innerhalb einer einzelnen Anfrage oder eines Vorgangs dieselbe Instanz bereitstellt. Diese Konsistenz ist besonders nützlich in Webanwendungen, wo gescopte Abhängigkeiten helfen, eine stabile Abhängigkeit während einer Webanfrage aufrechtzuerhalten.
2. Transient: Transiente Abhängigkeiten werden jedes Mal instanziiert, wenn sie vom Container angefordert werden. Dies bedeutet, dass jedes Mal, wenn eine transiente Abhängigkeit benötigt wird, eine neue Instanz erzeugt wird. Typischerweise werden transiente Abhängigkeiten für leichte, zustandslose Dienste oder Komponenten verwendet.
3. Singleton: Singleton-Abhängigkeiten werden nur einmal instanziiert und während der gesamten Lebensdauer der Anwendung geteilt. Dies stellt sicher, dass dieselbe Instanz einer Singleton-Abhängigkeit für alle Anfragen während der Dauer der Anwendung verwendet wird. Singleton-Abhängigkeiten werden typischerweise für zustandsbehaftete Dienste oder Komponenten verwendet, die universellen Zugriff über die gesamte Anwendung benötigen.

Installation Microsoft.Extensions.DependencyInjection Paket

Um in einem .NET Core-Projekt mit Dependency Injection zu beginnen, müssen Sie zunächst das Microsoft.Extensions.DependencyInjection-Paket installieren. Dies kann über die NuGet-Paket-Manager-Konsole in Visual Studio mit dem folgenden Befehl erfolgen:

Install-Package Microsoft.Extensions.DependencyInjection

Screenshot

Beispiel: Grundlegende Dependency Injection

In diesem Beispiel erstellen wir eine Beispielanwendung (Konsolenanwendung), in der wir einen Dienstanbieter verwenden, um Dienste aufzulösen und sie in unser Programm zu injizieren.

using Microsoft.Extensions.DependencyInjection;
using System;

// Define a service interface
public interface IMessageService
{
    void SendMessage(string message);
}

// Implement the service interface
public class ConsoleMessageService : IMessageService
{
    public void SendMessage(string message)
    {
        Console.WriteLine(message); // Output the message to the console
    }
}

using Microsoft.Extensions.DependencyInjection;
using System;

// Define a service interface
public interface IMessageService
{
    void SendMessage(string message);
}

// Implement the service interface
public class ConsoleMessageService : IMessageService
{
    public void SendMessage(string message)
    {
        Console.WriteLine(message); // Output the message to the console
    }
}

Imports Microsoft.Extensions.DependencyInjection
Imports System

' Define a service interface
Public Interface IMessageService
	Sub SendMessage(ByVal message As String)
End Interface

' Implement the service interface
Public Class ConsoleMessageService
	Implements IMessageService

	Public Sub SendMessage(ByVal message As String) Implements IMessageService.SendMessage
		Console.WriteLine(message) ' Output the message to the console
	End Sub
End Class

Imports Microsoft.Extensions.DependencyInjection
Imports System

' Define a service interface
Public Interface IMessageService
	Sub SendMessage(ByVal message As String)
End Interface

' Implement the service interface
Public Class ConsoleMessageService
	Implements IMessageService

	Public Sub SendMessage(ByVal message As String) Implements IMessageService.SendMessage
		Console.WriteLine(message) ' Output the message to the console
	End Sub
End Class

Das Code-Snippet erstellt eine Schnittstelle IMessageService zum Senden von Nachrichten, wie einen Vertrag dafür, wie Nachrichten gesendet werden sollen. Die Klasse ConsoleMessageService implementiert diese Schnittstelle, indem sie Console.WriteLine verwendet, um Nachrichten zu senden. Diese Trennung ermöglicht es, das Konzept des Nachrichtensendens unabhängig davon zu ändern, wie sie versendet werden, und macht das System flexibel und handhabbar.

class Program
{
    static void Main(string[] args)
    {
        // Create a service provider
        var serviceProvider = new ServiceCollection()
            // Register the service implementation
            .AddTransient<IMessageService, ConsoleMessageService>()
            .BuildServiceProvider();

        // Resolve the service
        var messageService = serviceProvider.GetRequiredService<IMessageService>();

        // Use the service to send a message
        messageService.SendMessage("Hello, From Dependency Injection!");
    }
}

class Program
{
    static void Main(string[] args)
    {
        // Create a service provider
        var serviceProvider = new ServiceCollection()
            // Register the service implementation
            .AddTransient<IMessageService, ConsoleMessageService>()
            .BuildServiceProvider();

        // Resolve the service
        var messageService = serviceProvider.GetRequiredService<IMessageService>();

        // Use the service to send a message
        messageService.SendMessage("Hello, From Dependency Injection!");
    }
}

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		' Create a service provider
		Dim serviceProvider = (New ServiceCollection()).AddTransient(Of IMessageService, ConsoleMessageService)().BuildServiceProvider()

		' Resolve the service
		Dim messageService = serviceProvider.GetRequiredService(Of IMessageService)()

		' Use the service to send a message
		messageService.SendMessage("Hello, From Dependency Injection!")
	End Sub
End Class

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		' Create a service provider
		Dim serviceProvider = (New ServiceCollection()).AddTransient(Of IMessageService, ConsoleMessageService)().BuildServiceProvider()

		' Resolve the service
		Dim messageService = serviceProvider.GetRequiredService(Of IMessageService)()

		' Use the service to send a message
		messageService.SendMessage("Hello, From Dependency Injection!")
	End Sub
End Class

Dieser Code richtet einen serviceProvider ein, um Dienste zu verwalten. Er registriert ConsoleMessageService als die Implementierung für IMessageService, und macht es verfügbar, um überall dort injiziert zu werden, wo es benötigt wird. Die Methode Main ruft dann eine Instanz von IMessageService aus dem serviceProvider ab und verwendet sie, um eine Nachricht an die Konsole zu senden.

Ausgabe: Das Programm druckt die Zeichenketten-Nachricht "Hello, From Dependency Injection!"

IronPDF: C# PDF-Bibliothek

IronPDF ist eine leistungsstarke Bibliothek für C#, die den komplexen Prozess der PDF-Erstellung vereinfacht und eine breite Palette von Funktionen zur PDF-Manipulation bietet, einschließlich der Möglichkeit, PDFs aus HTML zu generieren, Text zu PDFs hinzuzufügen und PDFs mit Bildern zu bearbeiten, sichere Dokumente zu erstellen und vieles mehr.

Verwendung von IronPDF mit Dependency Injection

Um die IronPDF-Bibliothek in eine .NET Core-Anwendung zu integrieren, die Dependency Injection-Funktionen und Erweiterungsmethoden mit Microsoft.Extensions.DependencyInjection nutzt, gehen Sie wie folgt vor:

1. Erstellen Sie ein Interface, um Ihren PDF-Erstellungsdienst zu definieren.
2. Implementieren Sie das Interface.
3. Verwenden Sie Erweiterungsmethoden, um den Dienst im Dependency Injection-Container zu registrieren.
4. Injizieren Sie den Dienst nach Bedarf in Ihre Anwendung.

Benutzeroberfläche definieren

Erstellen Sie ein Interface, um Ihren PDF-Erstellungsdienst zu definieren.

public interface IPdfService
{
    void GeneratePdf(string baseUrl, string query, string filePath);
}

public interface IPdfService
{
    void GeneratePdf(string baseUrl, string query, string filePath);
}

Public Interface IPdfService
    Sub GeneratePdf(baseUrl As String, query As String, filePath As String)
End Interface

Public Interface IPdfService
    Sub GeneratePdf(baseUrl As String, query As String, filePath As String)
End Interface

Implementiere Schnittstelle

Implementieren Sie das Interface unter Verwendung von IronPDF zur Erstellung der PDF-Datei.

using IronPdf;
using System;
using System.Web;

// Implement the PDF generation interface
public class IronPdfService : IPdfService
{
    public void GeneratePdf(string baseUrl, string query, string filePath)
    {
        License.LicenseKey = "Your-License-Key"; // Set the IronPDF license key
        string encodedQuery = HttpUtility.UrlEncode(query); // Encode the query string
        string fullUrl = $"{baseUrl}?query={encodedQuery}"; // Construct the full URL
        var renderer = new ChromePdfRenderer(); // Create a PDF renderer
        var pdf = renderer.RenderUrlAsPdf(fullUrl); // Render the PDF from the URL
        pdf.SaveAs(filePath); // Save the PDF to the specified file path
        Console.WriteLine($"PDF successfully created from: {fullUrl}");
        Console.WriteLine($"Saved to: {filePath}");
    }
}

using IronPdf;
using System;
using System.Web;

// Implement the PDF generation interface
public class IronPdfService : IPdfService
{
    public void GeneratePdf(string baseUrl, string query, string filePath)
    {
        License.LicenseKey = "Your-License-Key"; // Set the IronPDF license key
        string encodedQuery = HttpUtility.UrlEncode(query); // Encode the query string
        string fullUrl = $"{baseUrl}?query={encodedQuery}"; // Construct the full URL
        var renderer = new ChromePdfRenderer(); // Create a PDF renderer
        var pdf = renderer.RenderUrlAsPdf(fullUrl); // Render the PDF from the URL
        pdf.SaveAs(filePath); // Save the PDF to the specified file path
        Console.WriteLine($"PDF successfully created from: {fullUrl}");
        Console.WriteLine($"Saved to: {filePath}");
    }
}

Imports IronPdf
Imports System
Imports System.Web

' Implement the PDF generation interface
Public Class IronPdfService
	Implements IPdfService

	Public Sub GeneratePdf(ByVal baseUrl As String, ByVal query As String, ByVal filePath As String)
		License.LicenseKey = "Your-License-Key" ' Set the IronPDF license key
		Dim encodedQuery As String = HttpUtility.UrlEncode(query) ' Encode the query string
		Dim fullUrl As String = $"{baseUrl}?query={encodedQuery}" ' Construct the full URL
		Dim renderer = New ChromePdfRenderer() ' Create a PDF renderer
		Dim pdf = renderer.RenderUrlAsPdf(fullUrl) ' Render the PDF from the URL
		pdf.SaveAs(filePath) ' Save the PDF to the specified file path
		Console.WriteLine($"PDF successfully created from: {fullUrl}")
		Console.WriteLine($"Saved to: {filePath}")
	End Sub
End Class

Imports IronPdf
Imports System
Imports System.Web

' Implement the PDF generation interface
Public Class IronPdfService
	Implements IPdfService

	Public Sub GeneratePdf(ByVal baseUrl As String, ByVal query As String, ByVal filePath As String)
		License.LicenseKey = "Your-License-Key" ' Set the IronPDF license key
		Dim encodedQuery As String = HttpUtility.UrlEncode(query) ' Encode the query string
		Dim fullUrl As String = $"{baseUrl}?query={encodedQuery}" ' Construct the full URL
		Dim renderer = New ChromePdfRenderer() ' Create a PDF renderer
		Dim pdf = renderer.RenderUrlAsPdf(fullUrl) ' Render the PDF from the URL
		pdf.SaveAs(filePath) ' Save the PDF to the specified file path
		Console.WriteLine($"PDF successfully created from: {fullUrl}")
		Console.WriteLine($"Saved to: {filePath}")
	End Sub
End Class

Dienstleistung registrieren

Konfigurieren Sie in Ihrer Program.cs Klasse die Dependency Injection:

builder.Services.AddSingleton<IPdfService, IronPdfService>();

builder.Services.AddSingleton<IPdfService, IronPdfService>();

net

net

Diese Konfiguration löst Abhängigkeiten, indem das IPdfService-Interface mit IronPDFService implementiert wird, wobei eine Singleton-Dienstart für die PDF-Erstellung eingerichtet wird. Es wird dann in der gesamten Anwendung referenziert, um konsistente Funktionalität zur Erstellung von PDFs sicherzustellen.

Benutzung

Injizieren Sie IPdfService in Ihren Controller oder Dienst und verwenden Sie es:

public class MyController : Controller
{
    private readonly IPdfService _pdfService;
    
    public MyController(IPdfService pdfService)
    {
        _pdfService = pdfService;
    }
    
    public IActionResult GeneratePdf()
    {
        string baseUrl = "https://ironpdf.com/";
        string query = "Hello World from IronPDF !";
        string filePath = "Demo.pdf";
        
        // Use the injected PDF service to generate a PDF
        _pdfService.GeneratePdf(baseUrl, query, filePath);
        
        return View();
    }
}

public class MyController : Controller
{
    private readonly IPdfService _pdfService;
    
    public MyController(IPdfService pdfService)
    {
        _pdfService = pdfService;
    }
    
    public IActionResult GeneratePdf()
    {
        string baseUrl = "https://ironpdf.com/";
        string query = "Hello World from IronPDF !";
        string filePath = "Demo.pdf";
        
        // Use the injected PDF service to generate a PDF
        _pdfService.GeneratePdf(baseUrl, query, filePath);
        
        return View();
    }
}

Public Class MyController
    Inherits Controller

    Private ReadOnly _pdfService As IPdfService

    Public Sub New(pdfService As IPdfService)
        _pdfService = pdfService
    End Sub

    Public Function GeneratePdf() As IActionResult
        Dim baseUrl As String = "https://ironpdf.com/"
        Dim query As String = "Hello World from IronPDF !"
        Dim filePath As String = "Demo.pdf"

        ' Use the injected PDF service to generate a PDF
        _pdfService.GeneratePdf(baseUrl, query, filePath)

        Return View()
    End Function
End Class

Public Class MyController
    Inherits Controller

    Private ReadOnly _pdfService As IPdfService

    Public Sub New(pdfService As IPdfService)
        _pdfService = pdfService
    End Sub

    Public Function GeneratePdf() As IActionResult
        Dim baseUrl As String = "https://ironpdf.com/"
        Dim query As String = "Hello World from IronPDF !"
        Dim filePath As String = "Demo.pdf"

        ' Use the injected PDF service to generate a PDF
        _pdfService.GeneratePdf(baseUrl, query, filePath)

        Return View()
    End Function
End Class

Diese Konfiguration stellt sicher, dass der IronPDFService vom Microsoft Extensions Dependency Injection-Container erstellt und verwaltet wird. Sie können den standardmäßigen PDF-Erstellungsdienst mühelos durch eine alternative Implementierung des IPdfService-Interfaces ersetzen, ohne den Konsumcode ändern zu müssen.

Screenshot der PDF-Datei

Abschluss

Microsoft.Extensions.DependencyInjection ist ein leistungsstarkes Werkzeug in .NET 6 für die Implementierung der Dependency Injection, die lockere Kopplung fördert und die Testbarkeit von Anwendungen verbessert. Durch die Integration von IronPDF, einer funktionsreichen C#-Bibliothek, können Entwickler umfassende PDF-Dokumente mühelos erstellen. Lizenzierung für IronPDF ist verfügbar.