Microsoft.Extensions .DependencyInjection .NET 9 (Travailler avec PDF)

Microsoft.Extensions.DependencyInjection est une puissante bibliothèque fournie par Microsoft .NET pour faciliter l'injection de dépendances (Dependency Injection - DI), un modèle de conception logicielle qui favorise le couplage lâche et améliore la testabilité des applications. DI est souvent implémenté en utilisant le conteneur DI intégré de .NET Core ou des bibliothèques comme Autofac et Unity. L'ID consiste à injecter les dépendances (objets dont une classe a besoin) dans une classe plutôt que de laisser la classe créer ses dépendances. Cela se fait généralement par le biais d'un constructeur, d'une méthode ou d'une injection de propriété.

Conteneur d'injection de dépendance

1. Enregistrement du service : Les dépendances sont enregistrées dans un conteneur d'injection de dépendances (DI), généralement à la racine de composition de l'application. Ces enregistrements précisent 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épendance

• Injection par constructeur : Les services enregistrés sont fournis à une classe par le biais de son constructeur, ce qui est la forme la plus courante et recommandée d'injection de dépendances.
• Injection de méthode : Les services sont résolus et transmis comme paramètres à une méthode. Injection de propriété : Les services singleton ou les services à durée de vie limitée sont affectés à la classe.
• Injection de propriété : Les services singletons ou les services avec une durée de vie limitée à la portée peuvent être assignés aux propriétés de classe. Cependant, cette approche est moins courante et souvent considérée comme inférieure à l'injection de constructeur car elle peut introduire des dépendances cachées.

Comprendre les durées de vie dans l'injection de dépendance (DI) : Scoped, Transient et Singleton

1. Délimité: Les dépendances délimitées sont créées une fois par requête ou par portée de durée de vie, ce qui signifie que le conteneur fournit la même instance au sein d'une seule requête ou opération. Cette cohérence est particulièrement utile dans les applications web, où les dépendances scopées permettent de 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 signifie qu'une nouvelle instance d'une dépendance transitoire est générée chaque fois qu'elle est nécessaire. En règle générale, les dépendances transitoires sont utilisées pour des services ou des 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 la durée de l'application. Les dépendances singleton sont généralement utilisées pour les services ou les composants avec état qui doivent être universellement accessibles dans l'ensemble de 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 se faire via la console NuGet Package Manager dans Visual Studio avec le code suivant :

Install-Package Microsoft.Extensions.DependencyInjection

Install-Package Microsoft.Extensions.DependencyInjection

IRON VB CONVERTER ERROR developers@ironsoftware.com

Capture d'écran

Exemple : Injection de dépendance de base

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

using Microsoft.Extensions.DependencyInjection;
using System;
public interface IMessageService
{
    void SendMessage(string message);
}
public class ConsoleMessageService : IMessageService
{
    public void SendMessage(string message)
    {
        Console.WriteLine(message);
    }
}

using Microsoft.Extensions.DependencyInjection;
using System;
public interface IMessageService
{
    void SendMessage(string message);
}
public class ConsoleMessageService : IMessageService
{
    public void SendMessage(string message)
    {
        Console.WriteLine(message);
    }
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

L'extrait de code crée une règle d'envoi de messages appelée IMessageService. C'est comme si l'on établissait un plan pour l'envoi des messages. Ensuite, la classe ConsoleMessageService doit suivre cette règle en utilisant Console.WriteLine pour envoyer les messages. Cette configuration sépare l'idée d'envoyer des messages du processus proprement dit, ce qui permet de modifier plus facilement la manière dont les messages sont envoyés ultérieurement, si nécessaire. Il permet de maintenir le système de messagerie organisé et facile à gérer dans l'application.

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!");
    }
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

Ce code configure un serviceProvider pour gérer les outils. Il ajoute un outil ConsoleMessageService à celui-ci. Ensuite, il récupère l'outil IMessageService à partir de serviceProvider et l'utilise pour envoyer le message "Hello, Dependency Injection !" à la console.

Sortie : Le programme affiche le message de chaîne "Hello, From Dependency Injection!"

IronPDF : C&num ; Bibliothèque PDF

IronPDF est une bibliothèque puissante pour C# qui simplifie le processus complexe de génération de PDF, offrant une large gamme de fonctionnalités pour la manipulation de PDF, y compris la possibilité de générer des PDFs à partir de HTML, l'opération d'ajout de texte aux PDFs et d'éditer des PDFs avec des images, créer des documents sécurisés, et bien plus encore.

Utilisation d'IronPDF avec l'injection de dépendances

Pour intégrer la bibliothèque IronPDF dans une application .NET Core exploitant les fonctionnalités d'injection de dépendances et les 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. Mettre en œuvre l'interface.

3. Utiliser les méthodes d'extension pour enregistrer le service dans le conteneur d'injection de dépendances.

4. Injectez le service dans votre application si nécessaire.

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);
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

Mettre en œuvre l'interface

Mettre en œuvre l'interface en utilisant IronPDF pour créer le fichier PDF.

public class IronPdfService : IPdfService
{
    public void GeneratePdf(string baseUrl, string query, string filePath)
    {
        License.LicenseKey = "Your-License-Key";
        string encodedQuery = HttpUtility.UrlEncode(query);
        string fullUrl = $"{baseUrl}?query={encodedQuery}";
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderUrlAsPdf(fullUrl);
        pdf.SaveAs(filePath);
        Console.WriteLine($"PDF successfully created from: {fullUrl}");
        Console.WriteLine($"Saved to: {filePath}");
    }
}

public class IronPdfService : IPdfService
{
    public void GeneratePdf(string baseUrl, string query, string filePath)
    {
        License.LicenseKey = "Your-License-Key";
        string encodedQuery = HttpUtility.UrlEncode(query);
        string fullUrl = $"{baseUrl}?query={encodedQuery}";
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderUrlAsPdf(fullUrl);
        pdf.SaveAs(filePath);
        Console.WriteLine($"PDF successfully created from: {fullUrl}");
        Console.WriteLine($"Saved to: {filePath}");
    }
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

Service d'enregistrement

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

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

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

IRON VB CONVERTER ERROR developers@ironsoftware.com

Cette configuration résout les dépendances en mettant en œuvre l'interface IPdfService avec IronPdfService, établissant un type de service unique pour la génération de PDF. Il est ensuite référencé dans l'ensemble de l'application, ce qui garantit 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";
        _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";
        _pdfService.GeneratePdf(baseUrl, query, filePath);
        return View();
    }
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

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

Capture d'écran du fichier PDF

Conclusion

Microsoft.Extensions.DependencyInjection est un outil puissant dans .NET 6 pour mettre en œuvre l'injection de dépendances, qui favorise le couplage lâche et améliore la testabilité des applications. En intégrant IronPDF, une bibliothèque C# riche en fonctionnalités, les développeurs peuvent facilement générer des documents PDF complets avec un minimum d'efforts. Licences pour IronPDF sont disponibles.