Microsoft.Extensions.DependencyInjection .NET 9 (Arbeiten mit PDF)

Dependency Injection 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

Install-Package Microsoft.Extensions.DependencyInjection

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

Der Codeausschnitt erstellt eine Schnittstelle IMessageService zum Senden von Nachrichten, quasi einen Vertrag darüber, wie Nachrichten gesendet werden sollen. Die Klasse ConsoleMessageService implementiert diese Schnittstelle, indem sie Console.WriteLine zum Senden von Nachrichten verwendet. 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

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 vom Dienstanbieter ab und verwendet diese, 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.

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

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

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

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

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(ByVal 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

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.