Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. .NET Aide
  4. Microsoft-Extensions-DependencyInjection-NET-6
.NET AIDE

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

Curtis Chau
Curtis Chau
Mis à jour:

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é.

Microsoft.Extensions.DependencyInjection .NET 6 (Travailler avec le PDF) : Figure 1 - Documentation Microsoft.Extensions.DependencyInjectionName

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

Microsoft.Extensions.DependencyInjection .NET 6 (Travailler avec le PDF) : Figure 2 - Tapez la commande dans le terminal pour installer le package

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

Le fragment de code crée une interface IMessageService pour l'envoi de messages, comme un contrat pour la façon dont 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
$vbLabelText   $csharpLabel

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 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 !"

Microsoft.Extensions.DependencyInjection .NET 6 (Travailler avec le PDF) : Figure 3 - Sortie de la console du code ci-dessus

IronPDF : Bibliothèque PDF C

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 de modifier des PDF avec des images, créer des documents sécurisés, et bien plus encore.

Microsoft.Extensions.DependencyInjection .NET 6 (Travailler avec le PDF) : Figure 4 - Exemple en C# de Microsoft.Extensions.DependencyInjection (Comment cela fonctionne pour les développeurs) : Figure 2 - IronPDF

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);
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Implémenter l'interface

Implémentez l'interface en utilisant 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
$vbLabelText   $csharpLabel

Enregistrer le service

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

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

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 of the PDF File

Microsoft.Extensions.DependencyInjection .NET 6 (Travailler avec le PDF) : Figure 5 - Exemple de sortie utilisant le conteneur d'injection de dépendances Microsoft Extensions en conjonction avec IronPDF

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.

Questions Fréquemment Posées

Quel est le rôle de Microsoft.Extensions.DependencyInjection dans .NET 6 ?

Microsoft.Extensions.DependencyInjection dans .NET 6 est utilisé pour implémenter l'injection de dépendance, un modèle de conception qui aide à créer des applications faiblement couplées en gérant la durée de vie des services et les dépendances à l'aide d'un conteneur DI.

Comment l'injection de dépendances peut-elle améliorer la testabilité des applications ?

L'injection de dépendances améliore la testabilité en permettant d'injecter les dépendances dans une classe, ce qui facilite le remplacement des objets factices pendant les tests au lieu des implémentations réelles.

Quels sont les avantages de l'utilisation de l'injection de dépendances dans les applications .NET ?

Les avantages de l'utilisation de l'injection de dépendances dans les applications .NET incluent une meilleure maintenabilité du code, une évolutivité et la possibilité de gérer et de configurer facilement les dépendances à l'exécution.

Comment implémentez-vous l'injection de dépendances dans une application .NET Core ?

Dans une application .NET Core, l'injection de dépendances est implémentée en configurant des services dans le conteneur DI lors du démarrage de l'application et en les injectant dans les constructeurs ou méthodes selon les besoins.

Comment pouvez-vous convertir du HTML en PDF dans une application .NET Core ?

Vous pouvez convertir du HTML en PDF dans une application .NET Core en utilisant la méthode d'IronPDF comme RenderHtmlAsPdf pour les chaînes HTML ou RenderHtmlFileAsPdf pour les fichiers HTML.

Quels sont les différents durées de vie des services dans l'injection de dépendances et comment affectent-ils le comportement de l'application ?

Les durées de vie des services dans l'injection de dépendances sont Scoped, Transient et Singleton. Les services Scoped sont créés une fois par requête, les services Transient sont créés à chaque fois qu'ils sont demandés, et les services Singleton sont créés une fois et partagés dans toute l'application.

Comment pouvez-vous intégrer une bibliothèque PDF C# dans un projet .NET Core en utilisant l'injection de dépendances ?

Pour intégrer une bibliothèque PDF C# comme IronPDF dans un projet .NET Core en utilisant l'injection de dépendances, vous devez créer une interface pour les services PDF, l'implémenter, enregistrer le service dans le conteneur DI et l'injecter dans vos classes selon les besoins.

Quel est le processus d'installation du package Microsoft.Extensions.DependencyInjection ?

Le package Microsoft.Extensions.DependencyInjection peut être installé en utilisant la console du gestionnaire de packages NuGet dans Visual Studio avec la commande : Install-Package Microsoft.Extensions.DependencyInjection.

Comment IronPDF peut-il être utilisé avec l'injection de dépendances pour générer des PDF ?

IronPDF peut être utilisé avec l'injection de dépendances en configurant une interface de service PDF, en l'implémentant avec les méthodes de IronPDF, et en l'enregistrant dans le conteneur DI. Le service peut ensuite être injecté et utilisé pour générer des PDF à partir d'URL ou de contenu HTML.

Pouvez-vous remplacer une bibliothèque PDF C# dans une configuration DI sans altérer le code consommateur ?

Oui, vous pouvez remplacer une bibliothèque PDF C# dans une configuration DI en implémentant une alternative à l'interface utilisée pour les services PDF, vous permettant de changer de bibliothèque sans modifier le code consommateur.

Curtis Chau
Curtis Chau
  Discutez maintenant avec l'équipe d'ingénierie
Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes ...

Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Démarrer l'essai gratuit