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épendance(DI)il s'agit d'un modèle de conception de logiciel qui favorise le couplage lâche et améliore la testabilité des applications. L'identification automatique est souvent mise en œuvre à l'aide de.NET Core la traduction doit être professionnelle, en conservant la précision technique tout en expliquant les caractéristiques et les avantages de ces outils de développement. DI implique l'injection de dépendances(les objets dont une classe a besoin) dans une classe plutôt que la classe ne crée 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 des services: Les dépendances sont enregistrées dans un conteneur 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. **Lorsqu'un composant demande une dépendance, le conteneur DI la résout en créant une instance d'un type enregistré qui utilise une méthode d'extension.

Types d'injection de dépendance

• **Les services enregistrés sont fournis à une classe par l'intermédiaire de son constructeur, ce qui est la forme la plus courante et la plus recommandée de l'injection de constructeur.
• Injection de méthode: Les services sont résolus et transmis en tant que 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és : les services singleton ou les services à durée de vie limitée peuvent être assignés aux propriétés de la 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. **Les dépendances sont créées une fois par requête ou par durée de vie, ce qui signifie que le conteneur fournit la même instance au cours 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. **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. **Les dépendances singleton sont instanciées une seule fois et partagées pendant toute 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 demandes pendant toute la durée de vie 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 paquet Microsoft.Extensions.DependencyInjection

Pour commencer à utiliser l'injection de dépendances dans un projet .NET Core, vous devez d'abord installer l'extensionPaquet 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, nous allons créer un exemple d'application(application de la console) dans lequel nous utiliserons un fournisseur de services pour résoudre les 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 met en place un fournisseur de services pour gérer les outils. Il y ajoute un outil ConsoleMessageService. Ensuite, il récupère l'outil IMessageService de serviceProvider et l'utilise pour envoyer le message "Hello, Dependency Injection"!"à la console.

Sortie : Le programme imprime le message "Hello, From Dependency Injection"!"

IronPDF : C&num ; Bibliothèque PDF

IronPDF est une puissante bibliothèque pour C# qui simplifie le processus complexe de génération de PDF, offrant une large gamme de fonctionnalités pour la manipulation des PDF, y compris la possibilité de générer desPDF à partir de HTML, l'opération consistant à ajouterdu texte aux PDF etédition de PDF avec des images, la création de documents sécurisés, et bien d'autres choses 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. Licence pour IronPDF est disponible.