Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF
  2. IronPDF Blog
  3. .NET Hilfe
  4. Microsoft-Extensions-DependencyInjection-NET-6
.NET HILFE

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

Curtis Chau
Curtis Chau
Aktualisiert:

Microsoft.Extensions.DependencyInjection is a powerful library provided by Microsoft .NET to facilitate Dependency Injection (DI), a software design pattern that promotes loose coupling and enhances testability in applications. DI is often implemented using .NET Core built-in DI container or libraries like Autofac and Unity. DI involves injecting dependencies (objects a class needs) into a class rather than the class creating its dependencies. This is typically done through a constructor, method, or property injection.

Microsoft.Extensions.DependencyInjection .NET 6 (Working With PDF): Figure 1 - Microsoft.Extensions.DependencyInjectionName documentation

Dependency Injection Container

  1. Service Registration: Dependencies are registered in a DI container, typically at the application's composition root. These registrations specify how the container should create and manage the dependencies.

  2. Dependency Resolution: When a component requests a dependency, the DI container resolves the dependency by creating an instance of a registered type that uses an extension method.

Types of Dependency Injection

  • Constructor Injection: Registered services are provided to a class through its constructor, which is the most common and recommended form of DI.
  • Method Injection: Services are resolved and passed as parameters to a method.
  • Property Injection: Singleton services or services with a scoped lifetime can be assigned to class properties. However, this approach is less common and often considered inferior to constructor injection because it can introduce hidden dependencies.

Understanding Lifetimes in Dependency Injection (DI): Scoped, Transient, and Singleton

  1. Scoped: Scoped dependencies are created once per request or lifetime scope, meaning the container provides the same instance within a single request or operation. This consistency is particularly useful in web applications, where scoped dependencies help maintain a stable dependency throughout a web request.
  2. Transient: Transient dependencies are instantiated each time they are requested from the container. This implies that a new instance of a transient dependency is generated whenever it is needed. Typically, transient dependencies are used for lightweight, stateless services or components.
  3. Singleton: Singleton dependencies are instantiated only once and shared throughout the application's entire lifetime. This ensures that the same instance of a singleton dependency is used for all requests throughout the application's duration. Singleton dependencies are typically employed for stateful services or components that need to be universally accessible across the entire application.

Installing Microsoft.Extensions.DependencyInjection package

To start using dependency injection in a .NET Core project, you first need to install the Microsoft.Extensions.DependencyInjection package. This can be done through the NuGet Package Manager Console in Visual Studio with the following command:

Install-Package Microsoft.Extensions.DependencyInjection

Screenshot

Microsoft.Extensions.DependencyInjection .NET 6 (Working With PDF): Figure 2 - Type the command to the terminal to install the package

Example: Basic Dependency Injection

In this example, let's create a sample app (console application) wherein we'll utilize a service provider to resolve services and inject them into our program.

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
$vbLabelText   $csharpLabel

The code snippet creates an interface IMessageService for sending messages, like a contract for how messages should be sent. The ConsoleMessageService class implements this interface by using Console.WriteLine to send messages. This separation allows the concept of sending messages to be changed independently of how they are sent, making the system flexible and manageable.

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
$vbLabelText   $csharpLabel

This code sets up a serviceProvider to manage services. It registers ConsoleMessageService as the implementation for IMessageService, making it available to be injected wherever required. The Main method then retrieves an instance of IMessageService from the serviceProvider and uses it to send a message to the console.

Output: The program prints the string message "Hello, From Dependency Injection!"

Microsoft.Extensions.DependencyInjection .NET 6 (Working With PDF): Figure 3 - Console output from the code above

IronPDF: C# PDF Library

IronPDF is a powerful library for C# that simplifies the complex process of PDF generation, offering a wide range of features for PDF manipulation, including the ability to generate PDFs from HTML, operate adding text to PDFs and editing PDFs with images, creating secure documents, and much more.

Microsoft.Extensions.DependencyInjection .NET 6 (Working With PDF): Figure 4 - Microsoft.Extensions.DependencyInjection C# Example (How it Works For Developers): Figure 2 - IronPDF

Using IronPDF with Dependency Injection

To integrate the IronPDF library into a .NET Core application leveraging dependency injection features and extension methods with Microsoft.Extensions.DependencyInjection, you can proceed as follows:

  1. Create an interface to define your PDF generation service.
  2. Implement the interface.
  3. Utilize extension methods to register the service in the dependency injection container.
  4. Inject the service into your application as required.

Define Interface

Create an interface to define your PDF generation service.

public interface IPdfService
{
    void GeneratePdf(string baseUrl, string query, string filePath);
}
public interface IPdfService
{
    void GeneratePdf(string baseUrl, string query, string filePath);
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Implement Interface

Implement the interface using IronPDF for creating the PDF file.

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
$vbLabelText   $csharpLabel

Register Service

In your Program.cs class, configure dependency injection:

builder.Services.AddSingleton<IPdfService, IronPdfService>();
builder.Services.AddSingleton<IPdfService, IronPdfService>();
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

This setup resolves dependencies by implementing the IPdfService interface with IronPdfService, establishing a singleton service type for PDF generation. It is then referenced throughout the application, ensuring consistent functionality for generating PDFs.

Usage

Inject IPdfService into your controller or service and use it:

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
$vbLabelText   $csharpLabel

This setup ensures that the IronPdfService is created and managed by the Microsoft Extensions Dependency Injection container. You can effortlessly substitute the default PDF generation service by offering an alternative implementation for the IPdfService interface, all without altering the consuming code.

Screenshot of the PDF File

Microsoft.Extensions.DependencyInjection .NET 6 (Working With PDF): Figure 5 - Example output using Microsoft Extensions Dependency Injection container in conjunction with IronPDF

Conclusion

Microsoft.Extensions.DependencyInjection is a powerful tool in .NET 6 for implementing dependency injection, which promotes loose coupling and enhances testability in applications. By integrating IronPDF, a feature-rich C# library, developers can easily generate comprehensive PDF documents with minimal effort. Licensing for IronPDF is available.

Häufig gestellte Fragen

Welche Rolle spielt Microsoft.Extensions.DependencyInjection in .NET 6?

Microsoft.Extensions.DependencyInjection in .NET 6 wird verwendet, um Dependency Injection zu implementieren, ein Entwurfsmuster, das hilft, lose gekoppelte Anwendungen zu erstellen, indem Service-Lebensdauern und Abhängigkeiten mit einem DI-Container verwaltet werden.

Wie kann Dependency Injection die Testbarkeit in Anwendungen verbessern?

Dependency Injection verbessert die Testbarkeit, indem Abhängigkeiten in eine Klasse injiziert werden, was es einfacher macht, bei Tests Schein-Objekte anstelle von realen Implementierungen zu verwenden.

Welche Vorteile bietet die Verwendung von Dependency Injection in .NET-Anwendungen?

Die Vorteile der Verwendung von Dependency Injection in .NET-Anwendungen umfassen verbesserte Code-Wartbarkeit, Skalierbarkeit und die Fähigkeit, Abhängigkeiten zur Laufzeit leicht zu verwalten und zu konfigurieren.

Wie implementiert man Dependency Injection in einer .NET Core-Anwendung?

In einer .NET Core-Anwendung wird Dependency Injection implementiert, indem Dienste während des Anwendungsstarts im DI-Container konfiguriert und sie in Konstruktoren oder Methoden nach Bedarf injiziert werden.

Wie kann man HTML in einer .NET Core-Anwendung in PDF konvertieren?

Sie können HTML in einer .NET Core-Anwendung mit den Methoden von IronPDF konvertieren, wie RenderHtmlAsPdf für HTML-Strings oder RenderHtmlFileAsPdf für HTML-Dateien.

Welche verschiedenen Lebensdauern von Diensten gibt es bei Dependency Injection und wie beeinflussen sie das Anwendungsverhalten?

Die Dienstlebensdauern bei Dependency Injection sind Scoped, Transient und Singleton. Scoped-Dienste werden einmal pro Anforderung erstellt, Transient-Dienste werden jedes Mal erstellt, wenn sie angefordert werden, und Singleton-Dienste werden einmal erstellt und während der gesamten Anwendung geteilt.

Wie kann man eine C#-PDF-Bibliothek innerhalb eines .NET Core-Projekts mit Dependency Injection integrieren?

Um eine C#-PDF-Bibliothek wie IronPDF innerhalb eines .NET Core-Projekts mit Dependency Injection zu integrieren, müssen Sie eine Schnittstelle für PDF-Dienste erstellen, sie implementieren, den Dienst im DI-Container registrieren und nach Bedarf in Ihre Klassen injizieren.

Wie ist der Installationsprozess des Microsoft.Extensions.DependencyInjection-Pakets?

Das Microsoft.Extensions.DependencyInjection-Paket kann mit der NuGet-Paket-Manager-Konsole in Visual Studio mit dem Befehl Install-Package Microsoft.Extensions.DependencyInjection installiert werden.

Wie kann IronPDF mit Dependency Injection zur PDF-Erzeugung verwendet werden?

IronPDF kann mit Dependency Injection verwendet werden, indem ein PDF-Dienstinterface eingerichtet, mit IronPDF-Methoden implementiert und im DI-Container registriert wird. Der Dienst kann dann injiziert und verwendet werden, um PDFs aus URLs oder HTML-Inhalten zu erzeugen.

Kann man eine C#-PDF-Bibliothek in einer DI-Einrichtung ersetzen, ohne den konsumierenden Code zu ändern?

Ja, man kann eine C#-PDF-Bibliothek in einer DI-Einrichtung ersetzen, indem man eine Alternative zur Schnittstelle für PDF-Dienste implementiert, was es ermöglicht, Bibliotheken zu wechseln, ohne den konsumierenden Code zu ändern.

Curtis Chau
Curtis Chau
  Jetzt mit dem Ingenieurteam chatten
Technischer Autor

Curtis Chau hat einen Bachelor-Abschluss in Informatik von der Carleton University und ist spezialisiert auf Frontend-Entwicklung mit Expertise in Node.js, TypeScript, JavaScript und React. Leidenschaftlich widmet er sich der Erstellung intuitiver und ästhetisch ansprechender Benutzerschnittstellen und arbeitet gerne mit modernen Frameworks sowie der Erstellung gut strukturierter, optisch ansprechender ...

Weiterlesen

Verwandte Artikel

30-Tage-Testversion → Volles Produkt. Keine Grenzen. Keine Karte. Testversion