Que sont les génériques en C# ?

Les génériques C# introduisent un moyen de concevoir des classes, des méthodes, des interfaces et des délégués avec un paramètre de type. Cela permet la création de composants de code flexibles et réutilisables qui offrent une sécurité de type et des améliorations de performance.

Pouvez-vous donner un exemple de classe générique en C# ?

Oui, un exemple simple est une classe Box qui stocke une valeur de n'importe quel type. Vous pouvez créer des instances comme Box ou Box pour stocker différents types de données en utilisant la même classe.

Qu'est-ce qu'une méthode générique en C# ?

Une méthode générique est définie avec des paramètres de type au niveau de la méthode, lui permettant d'opérer sur différents types. Elle peut faire partie d'une classe non générique ou générique, offrant de la flexibilité dans la conception des méthodes.

Comment les interfaces génériques et les délégués peuvent-ils être utilisés en C# ?

Les interfaces et délégués génériques permettent la définition de contrats et de méthodes de rappel pouvant opérer avec n'importe quel type, améliorant la flexibilité et la réutilisation du code.

Quels sont les avantages d'utiliser des collections génériques en C# ?

Les collections génériques comme List et Dictionary offrent un stockage efficace et sécurisé de type pour tout type spécifique, éliminant le besoin de conversions et réduisant les erreurs d'exécution.

Comment puis-je créer des types génériques personnalisés en C# ?

Vous pouvez créer des types génériques personnalisés pour encapsuler des opérations communes à différents types de données mais gérés d'une manière spécifique au type, utiles pour construire des bibliothèques ou des utilitaires.

Comment les génériques C# peuvent-ils améliorer la génération de PDF en .NET ?

Les génériques C# peuvent être utilisés avec une bibliothèque PDF pour créer des composants flexibles et réutilisables. Par exemple, une classe PdfOptions peut être utilisée pour contenir des options de génération de PDF, démontrant l'adaptabilité des génériques avec les tâches PDF.

Comment une bibliothèque PDF peut-elle être utilisée avec les génériques C# ?

Une bibliothèque PDF, telle qu'IronPDF, peut utiliser les génériques C# pour améliorer sa fonctionnalité. Par exemple, une méthode générique pourrait être utilisée pour convertir HTML en PDF, offrant une approche flexible pour la génération de documents.

Quels sont les avantages d'utiliser les génériques C# ?

Les génériques C# permettent la réutilisation de code entre différents types de données, garantissent la vérification de type à la compilation, réduisent les erreurs d'exécution et améliorent la qualité globale du code. Ils permettent d'écrire un code adaptable et maintenable.

La Bibliothèque PDF C#

Q: Comment fonctionnent les classes génériques en C# ?

Une classe générique en C# utilise un paramètre de type, souvent désigné comme T , qui agit comme un espace réservé pour le type qu'elle contient ou sur lequel elle opère. Cela permet à la classe d'être instanciée avec divers types de données tout en maintenant la sécurité de type.

Explore IronPDF Essai gratuit

HTML en PDF

Online Demo Voir tous les exemples de code %s

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

PM >Install-Package IronPdf

Install-Package IronPdf

MISES À JOUR POUR LES DÉVELOPPEURS

C# Generics (Comment ça fonctionne pour les développeurs)

Jacob Mellor

Updated: 19 juillet 2026

Les génériques C# introduisent un moyen de concevoir des classes, des méthodes, des interfaces et des délégués où le type de données qu'ils gèrent peut être spécifié en tant que paramètre. Ce concept, connu sous le nom de paramètre de type générique, permet la création de composants de code flexibles et réutilisables. En utilisant les génériques, vous pouvez maximiser la réutilisation du code, la sécurité des types et la performance. Par exemple, une classe générique peut être définie une fois mais instanciée avec différents types de données, offrant ainsi polyvalence et intégrité des types. Dans cet article, nous apprendrons les bases des Génériques C# et les fonctionnalités de la bibliothèque IronPDF pour la manipulation de PDF.

Les bases des classes génériques

Une classe générique en C# est un modèle pour créer une classe avec un espace réservé pour le type qu'elle contient ou sur lequel elle opère. Cet espace réservé, souvent noté T, représente un paramètre de type qui est spécifié lorsque la classe est instanciée. Nous pouvons créer des classes génériques avec un paramètre de type T pour gérer divers types de données. Les classes génériques sont particulièrement utiles pour les classes de collection, comme les listes, files d'attente et tables de hachage, car elles peuvent contenir n'importe quel type de données tout en garantissant la sécurité des types et en réduisant le besoin de conversion de type.

Exemple simple d'une classe générique

Considérons une classe générique nommée Boîte conçue pour stocker une valeur de n'importe quel type :

public class Box<t>
{
    private T data;

    public Box(T data)
    {
        this.data = data;
    }

    public T Data
    {
        get { return data; }
    }
}

public class Box<t>
{
    private T data;

    public Box(T data)
    {
        this.data = data;
    }

    public T Data
    {
        get { return data; }
    }
}

Public Class Box(Of T)
    Private data As T

    Public Sub New(data As T)
        Me.data = data
    End Sub

    Public ReadOnly Property Data As T
        Get
            Return data
        End Get
    End Property
End Class

Public Class Box(Of T)
    Private data As T

    Public Sub New(data As T)
        Me.data = data
    End Sub

    Public ReadOnly Property Data As T
        Get
            Return data
        End Get
    End Property
End Class

Pour utiliser cette classe, vous créez une instance en spécifiant le type réel de T :

Box<int> integerBox = new Box<int>(123);
Box<string> stringBox = new Box<string>("Hello");

Box<int> integerBox = new Box<int>(123);
Box<string> stringBox = new Box<string>("Hello");

Dim integerBox As New Box(Of Integer)(123)
Dim stringBox As New Box(Of String)("Hello")

Dim integerBox As New Box(Of Integer)(123)
Dim stringBox As New Box(Of String)("Hello")

Ce code illustre comment une seule classe (Boîte) peut s'adapter pour stocker différents types de données (int, string), démontrant la puissance des génériques pour la réutilisation du code et la sécurité des types.

Implémentation des méthodes génériques

Les méthodes génériques sont similaires aux classes génériques mais sont définies avec des paramètres de type au niveau de la méthode. Cela permet de créer des méthodes pouvant opérer sur différents types tout en étant définies dans une classe non générique ou générique.

Exemple de méthode générique

Voici une méthode qui échange deux éléments dans un tableau de n'importe quel type :

public class Utility
{
    // Swaps two elements by reference using generics
    public static void Swap<t>(ref T lhs, ref T rhs)
    {
        T temp = lhs; // Store lhs in a temporary variable
        lhs = rhs;    // Assign rhs to lhs
        rhs = temp;   // Assign temp (original lhs) to rhs
    }
}

public class Utility
{
    // Swaps two elements by reference using generics
    public static void Swap<t>(ref T lhs, ref T rhs)
    {
        T temp = lhs; // Store lhs in a temporary variable
        lhs = rhs;    // Assign rhs to lhs
        rhs = temp;   // Assign temp (original lhs) to rhs
    }
}

Public Class Utility
    ' Swaps two elements by reference using generics
    Public Shared Sub Swap(Of T)(ByRef lhs As T, ByRef rhs As T)
        Dim temp As T = lhs ' Store lhs in a temporary variable
        lhs = rhs ' Assign rhs to lhs
        rhs = temp ' Assign temp (original lhs) to rhs
    End Sub
End Class

Public Class Utility
    ' Swaps two elements by reference using generics
    Public Shared Sub Swap(Of T)(ByRef lhs As T, ByRef rhs As T)
        Dim temp As T = lhs ' Store lhs in a temporary variable
        lhs = rhs ' Assign rhs to lhs
        rhs = temp ' Assign temp (original lhs) to rhs
    End Sub
End Class

L'utilisation de la méthode ci-dessus peut se faire comme suit :

int a = 1, b = 2;
Utility.Swap<int>(ref a, ref b);

string first = "world", second = "hello";
Utility.Swap(ref first, ref second);

int a = 1, b = 2;
Utility.Swap<int>(ref a, ref b);

string first = "world", second = "hello";
Utility.Swap(ref first, ref second);

Dim a As Integer = 1, b As Integer = 2
Utility.Swap(Of Integer)(a, b)

Dim first As String = "world", second As String = "hello"
Utility.Swap(first, second)

Dim a As Integer = 1, b As Integer = 2
Utility.Swap(Of Integer)(a, b)

Dim first As String = "world", second As String = "hello"
Utility.Swap(first, second)

Exploration des interfaces et délégués génériques

Les interfaces et délégués génériques permettent de définir des contrats et des méthodes de rappel pouvant opérer sur n'importe quel type. Implémenter une interface générique ou utiliser un délégué générique dans votre classe ou méthode améliore la flexibilité et la réutilisation du code.

Exemple d'interface générique

Une interface de dépôt générique pour les opérations d'accès aux données pourrait ressembler à ceci :

public interface IRepository<t>
{
    void Add(T item);
    T GetById(int id);
    IEnumerable<t> GetAll();
}

public interface IRepository<t>
{
    void Add(T item);
    T GetById(int id);
    IEnumerable<t> GetAll();
}

Public Interface IRepository(Of T)
    Sub Add(item As T)
    Function GetById(id As Integer) As T
    Function GetAll() As IEnumerable(Of T)
End Interface

Public Interface IRepository(Of T)
    Sub Add(item As T)
    Function GetById(id As Integer) As T
    Function GetAll() As IEnumerable(Of T)
End Interface

Cette interface peut être implémentée par n'importe quelle classe pour gérer des types de données spécifiques, permettant des modèles d'accès aux données cohérents à travers différents types.

Exemple de délégué générique

Un délégué générique pourrait être utilisé pour définir un rappel sécurisé par type :

public delegate void Action<t>(T item);

public delegate void Action<t>(T item);

Public Delegate Sub Action(Of T)(item As T)

Public Delegate Sub Action(Of T)(item As T)

Utilisation des collections génériques

Les classes de collection génériques, telles que List, Dictionary<TKey, TValue> et autres dans l'espace de noms System.Collections.Generic, offrent des collections efficaces et sécurisées par type pour stocker et manipuler les données de n'importe quel type spécifique. Ces collections sont supérieures à leurs homologues non génériques car elles éliminent le besoin de conversion de type et réduisent les erreurs d'exécution.

List<string> names = new List<string>();
names.Add("Alice");
names.Add("Bob");

Dictionary<int, string> keyValuePairs = new Dictionary<int, string>();
keyValuePairs.Add(1, "One");
keyValuePairs.Add(2, "Two");

List<string> names = new List<string>();
names.Add("Alice");
names.Add("Bob");

Dictionary<int, string> keyValuePairs = new Dictionary<int, string>();
keyValuePairs.Add(1, "One");
keyValuePairs.Add(2, "Two");

Dim names As New List(Of String)()
names.Add("Alice")
names.Add("Bob")

Dim keyValuePairs As New Dictionary(Of Integer, String)()
keyValuePairs.Add(1, "One")
keyValuePairs.Add(2, "Two")

Dim names As New List(Of String)()
names.Add("Alice")
names.Add("Bob")

Dim keyValuePairs As New Dictionary(Of Integer, String)()
keyValuePairs.Add(1, "One")
keyValuePairs.Add(2, "Two")

Créer des types génériques personnalisés

Au-delà de l'utilisation de types génériques intégrés, vous pouvez créer les vôtres pour encapsuler des opérations courantes à travers différents types de données mais nécessitant d'être traités de manière spécifique au type. Cette approche est particulièrement utile pour construire des bibliothèques, des frameworks ou des utilitaires à utiliser avec divers types de données.

Exemple de type générique personnalisé

Considérons une classe générique Résultat qui encapsule les résultats d'opérations avec un indicateur de succès et un message optionnel :

public class Result<t>
{
    public bool Success { get; private set; }
    public T Data { get; private set; }
    public string Message { get; private set; }

    public Result(bool success, T data, string message = "")
    {
        Success = success;
        Data = data;
        Message = message;
    }
}

public class Result<t>
{
    public bool Success { get; private set; }
    public T Data { get; private set; }
    public string Message { get; private set; }

    public Result(bool success, T data, string message = "")
    {
        Success = success;
        Data = data;
        Message = message;
    }
}

Public Class Result(Of T)
    Public ReadOnly Property Success As Boolean
    Public ReadOnly Property Data As T
    Public ReadOnly Property Message As String

    Public Sub New(success As Boolean, data As T, Optional message As String = "")
        Me.Success = success
        Me.Data = data
        Me.Message = message
    End Sub
End Class

Public Class Result(Of T)
    Public ReadOnly Property Success As Boolean
    Public ReadOnly Property Data As T
    Public ReadOnly Property Message As String

    Public Sub New(success As Boolean, data As T, Optional message As String = "")
        Me.Success = success
        Me.Data = data
        Me.Message = message
    End Sub
End Class

IronPDF : Bibliothèque PDF en C#

IronPDF est une bibliothèque complète conçue pour les développeurs .NET pour créer, éditer et extraire des documents PDF au sein de leurs applications. IronPDF aide à générer des PDF à partir de HTML, éditer des PDF existants, convertir des PDF en images, et bien plus. Bien que IronPDF lui-même ne soit pas basé sur des génériques, comprendre comment interagir avec cette bibliothèque dans un environnement C# peut grandement améliorer les capacités de gestion de documents de votre application.

Exemple de code : Utilisation du mot-clé virtual avec IronPDF

L'idée ici est de créer une méthode réutilisable pouvant générer un PDF à partir de n'importe quelle chaîne HTML donnée. Cette méthode sera générique, nous permettant de spécifier différents types de métadonnées ou configurations selon les besoins.

Tout d'abord, définissons une classe générique simple qui contiendra nos options de génération de PDF. À des fins de démonstration, cette classe sera basique, mais vous pouvez l'élargir avec plus de propriétés pour répondre à vos besoins.

public class PdfOptions<t>
{
    public T Metadata { get; set; }
    public string HtmlContent { get; set; }
}

public class PdfOptions<t>
{
    public T Metadata { get; set; }
    public string HtmlContent { get; set; }
}

Public Class PdfOptions(Of T)
    Public Property Metadata As T
    Public Property HtmlContent As String
End Class

Public Class PdfOptions(Of T)
    Public Property Metadata As T
    Public Property HtmlContent As String
End Class

Ensuite, créons une méthode statique qui génère un PDF avec IronPDF, en s'appuyant sur notre classe PdfOptions. Cette méthode prendra une instance de PdfOptions en paramètre, démontrant l'utilisation des génériques en action.

using IronPdf; // Make sure to include the necessary namespace for IronPDF

public static class PdfGenerator
{
    // Generates a PDF from provided HTML content and options
    public static void GeneratePdf<t>(PdfOptions<t> options)
    {
        // Initialize the IronPDF HtmlToPdf renderer
        var renderer = new ChromePdfRenderer();

        // Optional: Apply any renderer options here, for example, setting the paper size
        renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4;

        // Generate the PDF from HTML content
        var pdfDocument = renderer.RenderHtmlAsPdf(options.HtmlContent);

        // Optional: Here, you can use options.Metadata in some way, depending on your generic type T
        // For simplicity, we're just printing the metadata to console if it's of type string
        if (options.Metadata is string metadataString)
        {
            Console.WriteLine($"Metadata: {metadataString}");
        }

        // Save the PDF to a file
        var fileName = $"GeneratedPdf_{DateTime.Now.Ticks}.pdf";
        pdfDocument.SaveAs(fileName);
        Console.WriteLine($"PDF generated and saved as {fileName}");
    }
}

using IronPdf; // Make sure to include the necessary namespace for IronPDF

public static class PdfGenerator
{
    // Generates a PDF from provided HTML content and options
    public static void GeneratePdf<t>(PdfOptions<t> options)
    {
        // Initialize the IronPDF HtmlToPdf renderer
        var renderer = new ChromePdfRenderer();

        // Optional: Apply any renderer options here, for example, setting the paper size
        renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4;

        // Generate the PDF from HTML content
        var pdfDocument = renderer.RenderHtmlAsPdf(options.HtmlContent);

        // Optional: Here, you can use options.Metadata in some way, depending on your generic type T
        // For simplicity, we're just printing the metadata to console if it's of type string
        if (options.Metadata is string metadataString)
        {
            Console.WriteLine($"Metadata: {metadataString}");
        }

        // Save the PDF to a file
        var fileName = $"GeneratedPdf_{DateTime.Now.Ticks}.pdf";
        pdfDocument.SaveAs(fileName);
        Console.WriteLine($"PDF generated and saved as {fileName}");
    }
}

Imports IronPdf ' Make sure to include the necessary namespace for IronPDF

Public Module PdfGenerator
    ' Generates a PDF from provided HTML content and options
    Public Sub GeneratePdf(Of T)(options As PdfOptions(Of T))
        ' Initialize the IronPDF HtmlToPdf renderer
        Dim renderer As New ChromePdfRenderer()

        ' Optional: Apply any renderer options here, for example, setting the paper size
        renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4

        ' Generate the PDF from HTML content
        Dim pdfDocument = renderer.RenderHtmlAsPdf(options.HtmlContent)

        ' Optional: Here, you can use options.Metadata in some way, depending on your generic type T
        ' For simplicity, we're just printing the metadata to console if it's of type string
        If TypeOf options.Metadata Is String Then
            Dim metadataString As String = CType(options.Metadata, String)
            Console.WriteLine($"Metadata: {metadataString}")
        End If

        ' Save the PDF to a file
        Dim fileName As String = $"GeneratedPdf_{DateTime.Now.Ticks}.pdf"
        pdfDocument.SaveAs(fileName)
        Console.WriteLine($"PDF generated and saved as {fileName}")
    End Sub
End Module

Imports IronPdf ' Make sure to include the necessary namespace for IronPDF

Public Module PdfGenerator
    ' Generates a PDF from provided HTML content and options
    Public Sub GeneratePdf(Of T)(options As PdfOptions(Of T))
        ' Initialize the IronPDF HtmlToPdf renderer
        Dim renderer As New ChromePdfRenderer()

        ' Optional: Apply any renderer options here, for example, setting the paper size
        renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4

        ' Generate the PDF from HTML content
        Dim pdfDocument = renderer.RenderHtmlAsPdf(options.HtmlContent)

        ' Optional: Here, you can use options.Metadata in some way, depending on your generic type T
        ' For simplicity, we're just printing the metadata to console if it's of type string
        If TypeOf options.Metadata Is String Then
            Dim metadataString As String = CType(options.Metadata, String)
            Console.WriteLine($"Metadata: {metadataString}")
        End If

        ' Save the PDF to a file
        Dim fileName As String = $"GeneratedPdf_{DateTime.Now.Ticks}.pdf"
        pdfDocument.SaveAs(fileName)
        Console.WriteLine($"PDF generated and saved as {fileName}")
    End Sub
End Module

Enfin, utilisons notre classe PdfGenerator pour générer un document PDF. Dans cet exemple, la propriété Metadata pourrait être une chaîne contenant un titre ou toute autre information que vous jugez pertinente.

class Program
{
    static void Main(string[] args)
    {
        // Set the license key for IronPDF if needed
        License.LicenseKey = "Your-License-Key-Here";

        // Create PDF options with HTML content and metadata
        var options = new PdfOptions<string>
        {
            HtmlContent = "<h1>Hello, World!</h1><p>This is a test PDF document generated from HTML.</p>",
            Metadata = "Test PDF Title"
        };

        // Generate the PDF using the specified options
        PdfGenerator.GeneratePdf(options);
    }
}

class Program
{
    static void Main(string[] args)
    {
        // Set the license key for IronPDF if needed
        License.LicenseKey = "Your-License-Key-Here";

        // Create PDF options with HTML content and metadata
        var options = new PdfOptions<string>
        {
            HtmlContent = "<h1>Hello, World!</h1><p>This is a test PDF document generated from HTML.</p>",
            Metadata = "Test PDF Title"
        };

        // Generate the PDF using the specified options
        PdfGenerator.GeneratePdf(options);
    }
}

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		' Set the license key for IronPDF if needed
		License.LicenseKey = "Your-License-Key-Here"

		' Create PDF options with HTML content and metadata
		Dim options = New PdfOptions(Of String) With {
			.HtmlContent = "<h1>Hello, World!</h1><p>This is a test PDF document generated from HTML.</p>",
			.Metadata = "Test PDF Title"
		}

		' Generate the PDF using the specified options
		PdfGenerator.GeneratePdf(options)
	End Sub
End Class

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		' Set the license key for IronPDF if needed
		License.LicenseKey = "Your-License-Key-Here"

		' Create PDF options with HTML content and metadata
		Dim options = New PdfOptions(Of String) With {
			.HtmlContent = "<h1>Hello, World!</h1><p>This is a test PDF document generated from HTML.</p>",
			.Metadata = "Test PDF Title"
		}

		' Generate the PDF using the specified options
		PdfGenerator.GeneratePdf(options)
	End Sub
End Class

Cet exemple illustre les bases de l'intégration d'IronPDF avec les génériques C#, fournissant un moyen flexible de générer des PDF à partir de contenu HTML tout en permettant des métadonnées ou configurations personnalisables via la classe générique PdfOptions. Vous pouvez étoffer cela en ajoutant des options plus sophistiquées et des configurations de rendu selon les besoins de votre application.

Génériques C# (Comment cela fonctionne pour les développeurs) : Figure 1 - Exemple de sortie de code utilisant des génériques pour créer un document PDF à partir d'une chaîne HTML avec IronPDF

Conclusion

Les génériques C# sont un outil puissant pour développer du code de haute qualité, réutilisable et sécurisé par type. En comprenant et en appliquant des classes, méthodes, interfaces et délégués génériques, vous pouvez écrire du code plus adaptable et facile à maintenir. Les génériques permettent non seulement la réutilisation du code à travers différents types de données, mais garantissent également une vérification de type à la compilation, ce qui réduit les erreurs d'exécution et améliore la qualité globale du code. IronPDF propose un essai gratuit de ses outils de bibliothèque PDF, avec des coûts à partir de $999.

Jacob Mellor

Discutez maintenant avec l'équipe d'ingénierie

Directeur technique

Jacob Mellor est directeur de la technologie chez Iron Software et un ingénieur visionnaire pionnier de la technologie C# PDF. En tant que développeur à l'origine de la base de code centrale d'Iron Software, il a façonné l'architecture des produits de l'entreprise depuis sa création, la transformant aux côtés du PDG Cameron Rimington en une entreprise de plus de 50 personnes au service de la NASA, de Tesla et d'agences gouvernementales mondiales.

...