La bibliothèque Microsoft.Extensions.DependencyInjection est une puissante bibliothèque fournie par Microsoft .NET pour faciliter l'injection de dépendances (DI), un modèle de conception logicielle qui favorise le couplage lâche et améliore la testabilité des applications. La DI est souvent mise en œuvre en utilisant le conteneur DI intégré de .NET Core ou des bibliothèques comme Autofac et Unity. La DI consiste à injecter des dépendances (objets dont une classe a besoin) dans une classe au lieu que la classe crée ses dépendances. Cela se fait généralement par injection de constructeur, de méthode ou de propriété.

Conteneur d'injection de dépendances

1. Enregistrement de service : Les dépendances sont enregistrées dans un conteneur DI, généralement à la racine de composition de l'application. Ces enregistrements spécifient comment le conteneur doit créer et gérer les dépendances.

2. Résolution des dépendances : Lorsqu'un composant demande une dépendance, le conteneur DI résout la dépendance en créant une instance d'un type enregistré qui utilise une méthode d'extension.

Types d'injection de dépendances

• Injection par constructeur : Les services enregistrés sont fournis à une classe par son constructeur, qui est la forme la plus courante et recommandée de DI.
• Injection par méthode : Les services sont résolus et passés en tant que paramètres à une méthode.
• Injection par propriété : Les services Singleton ou les services à durée de vie limitée peuvent être attribués aux propriétés de la classe. Cependant, cette approche est moins courante et souvent considérée comme inférieure à l'injection par constructeur car elle peut introduire des dépendances cachées.

Comprendre les durées de vie dans l'injection de dépendances (DI) : Spécifique, Transitoire et Singleton

1. Spécifique : Les dépendances spécifiques sont créées une fois par demande ou portée de vie, ce qui signifie que le conteneur fournit la même instance lors d'une seule demande ou opération. Cette cohérence est particulièrement utile dans les applications Web, où les dépendances spécifiques aident à maintenir une dépendance stable tout au long d'une requête Web.
2. Transitoire : Les dépendances transitoires sont instanciées chaque fois qu'elles sont demandées au conteneur. Cela implique qu'une nouvelle instance d'une dépendance transitoire est générée à chaque fois qu'elle est nécessaire. Typiquement, les dépendances transitoires sont utilisées pour les services ou composants légers et sans état.
3. Singleton : Les dépendances Singleton sont instanciées une seule fois et partagées tout au long de la durée de vie de l'application. Cela garantit que la même instance d'une dépendance Singleton est utilisée pour toutes les requêtes pendant toute la durée de l'application. Les dépendances Singleton sont généralement utilisées pour les services ou composants avec état qui doivent être universellement accessibles dans toute l'application.

Installation du package Microsoft.Extensions.DependencyInjection

Pour commencer à utiliser l'injection de dépendances dans un projet .NET Core, vous devez d'abord installer le package Microsoft.Extensions.DependencyInjection. Cela peut être fait via la console de gestionnaire de packages NuGet dans Visual Studio avec la commande suivante :

Install-Package Microsoft.Extensions.DependencyInjection

Capture d'écran

Exemple : Injection de dépendances de base

Dans cet exemple, créons une application exemple (application console) dans laquelle nous utiliserons un fournisseur de services pour résoudre les services et les injecter dans notre programme.

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

L'extrait de code crée une interface IMessageService pour l'envoi de messages, comme un contrat précisant comment les messages doivent être envoyés. La classe ConsoleMessageService implémente cette interface en utilisant Console.WriteLine pour envoyer des messages. Cette séparation permet de modifier le concept d'envoi de messages indépendamment de la manière dont ils sont envoyés, ce qui rend le système flexible et gérable.

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

Ce code configure un serviceProvider pour gérer les services. Il enregistre ConsoleMessageService comme implémentation de IMessageService, le rendant disponible pour être injecté où nécessaire. La méthode Main récupère ensuite une instance de IMessageService à partir du serviceProvider et l'utilise pour envoyer un message à la console.

Sortie : Le programme imprime le message de chaîne "Bonjour, depuis l'injection de dépendances !"

IronPDF : Bibliothèque PDF en C#

IronPDF est une bibliothèque puissante pour C# qui simplifie le processus complexe de génération de PDF, offrant un large éventail de fonctionnalités pour la manipulation de PDF, y compris la capacité de générer des PDF à partir de HTML, d'opérer en ajoutant du texte aux PDF et de modifier des PDF avec des images, créer des documents sécurisés, et bien plus encore.

Utiliser IronPDF avec l'injection de dépendances

Pour intégrer la bibliothèque IronPDF dans une application .NET Core tirant parti des fonctionnalités d'injection de dépendances et des méthodes d'extension avec Microsoft.Extensions.DependencyInjection, vous pouvez procéder comme suit :

1. Créez une interface pour définir votre service de génération de PDF.
2. Implémentez l'interface.
3. Utilisez les méthodes d'extension pour enregistrer le service dans le conteneur d'injection de dépendances.
4. Injectez le service dans votre application selon les besoins.

Définir l'interface

Créez une interface pour définir votre service de génération de PDF.

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

Implémenter l'interface

Implémentez l'interface avec IronPDF pour créer le fichier PDF.

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

Enregistrer le service

Dans votre classe Program.cs, configurez l'injection de dépendances :

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

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

net

net

Cette configuration résout les dépendances en implémentant l'interface IPdfService avec IronPDFService, établissant un type de service singleton pour la génération de PDF. Il est ensuite référencé dans toute l'application, garantissant une fonctionnalité cohérente pour la génération de PDF.

Utilisation

Injectez IPdfService dans votre contrôleur ou service et utilisez-le :

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

Cette configuration garantit que IronPDFService est créé et géré par le conteneur d'injection de dépendances Microsoft Extensions. Vous pouvez remplacer facilement le service de génération de PDF par défaut en proposant une implémentation alternative pour l'interface IPdfService, sans modifier le code consommateur.

Capture d'écran du fichier PDF

Conclusion

Microsoft.Extensions.DependencyInjection est un outil puissant dans .NET 6 pour implémenter l'injection de dépendances, qui favorise le couplage lâche et améliore la testabilité des applications. En intégrant IronPDF, une riche bibliothèque C#, les développeurs peuvent facilement générer des documents PDF complets avec un effort minimal. La licence pour IronPDF est disponible.