Génériques C# (Comment ça marche pour les développeurs)

Les génériques C# permettent de concevoir des classes, des méthodes, des interfaces et des délégués pour lesquels 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 de créer des composants de code flexibles et réutilisables. En utilisantgénériquesvous pouvez maximiser la réutilisation du code, la sécurité des types et les performances. Par exemple, une classe générique peut être définie une seule fois mais instanciée avec différents types de données, offrant ainsi polyvalence et intégrité des types. Dans cet article, nous allons apprendre les bases de C# Generics et deFonctionnalités de la bibliothèque IronPDF pour la manipulation des PDF.

Les bases des classes génériques

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

Exemple simple de classe générique

Considérons une classe générique nommée Box 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)
'INSTANT VB NOTE: The field data was renamed since Visual Basic does not allow fields to have the same name as other class members:
	Private data_Conflict As T
	Public Sub New(ByVal data As T)
		Me.data_Conflict = data
	End Sub
	Public ReadOnly Property Data() As T
		Get
			Return data_Conflict
		End Get
	End Property
End Class

Pour utiliser cette classe, vous devez créer une instance 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")

Ce code illustre comment une classe unique(Box) peut s'adapter pour stocker différents types de données(int, string)qui montre la puissance des génériques pour la réutilisation du code et la sécurité des types.

Mise en œuvre de 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 qui peuvent 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 permet d'échanger deux éléments dans un tableau de n'importe quel type :

public class Utility
{
    public static void Swap<T>(ref T lhs, ref T rhs)
    {
        T temp = lhs;
        lhs = rhs;
        rhs = temp;
    }
}

public class Utility
{
    public static void Swap<T>(ref T lhs, ref T rhs)
    {
        T temp = lhs;
        lhs = rhs;
        rhs = temp;
    }
}

Public Class Utility
	Public Shared Sub Swap(Of T)(ByRef lhs As T, ByRef rhs As T)
		Dim temp As T = lhs
		lhs = rhs
		rhs = temp
	End Sub
End Class

La méthode ci-dessus peut être utilisée 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)

Explorer les interfaces génériques et les délégués

Les interfaces génériques et les délégués permettent de définir des contrats et des méthodes de rappel qui peuvent fonctionner avec n'importe quel type. La mise en œuvre d'une interface générique ou l'utilisation d'un délégué générique dans votre classe ou votre méthode améliore la flexibilité et la réutilisation du code.

Exemple d'interface générique

Une interface générique de dépôt 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(ByVal item As T)
	Function GetById(ByVal id As Integer) As T
	Function GetAll() As IEnumerable(Of T)
End Interface

Cette interface peut être mise en œuvre par n'importe quelle classe pour gérer des types de données spécifiques, ce qui permet d'obtenir des modèles d'accès aux données cohérents pour différents types de données.

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

Un délégué générique pourrait être utilisé pour définir un rappel de type sûr :

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

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

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

Utilisation des collections génériques

Classes de collection génériques, telles que List, Dictionnaire<TKey, TValue>, et d'autres dans l'espace de noms System.Collections.Generic, offrent des collections efficaces et sûres pour le stockage et la manipulation de 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 moulage 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")

Création de types génériques personnalisés

Outre l'utilisation des types génériques intégrés, vous pouvez créer les vôtres pour encapsuler les opérations communes à différents types de données, mais qui doivent être gérées d'une manière spécifique à chaque type. Cette approche est particulièrement utile pour construire des bibliothèques, des cadres ou des utilitaires qui doivent être utilisés avec différents types de données.

Exemple de type générique personnalisé

Considérons une classe générique Result qui encapsule les résultats d'une opération avec un indicateur de réussite et un message facultatif :

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)
	Private privateSuccess As Boolean
	Public Property Success() As Boolean
		Get
			Return privateSuccess
		End Get
		Private Set(ByVal value As Boolean)
			privateSuccess = value
		End Set
	End Property
	Private privateData As T
	Public Property Data() As T
		Get
			Return privateData
		End Get
		Private Set(ByVal value As T)
			privateData = value
		End Set
	End Property
	Private privateMessage As String
	Public Property Message() As String
		Get
			Return privateMessage
		End Get
		Private Set(ByVal value As String)
			privateMessage = value
		End Set
	End Property
	Public Sub New(ByVal success As Boolean, ByVal data As T, Optional ByVal message As String = "")
		Me.Success = success
		Me.Data = data
		Me.Message = message
	End Sub
End Class

IronPDF : Bibliothèque PDF C

IronPDF est une bibliothèque complète conçue pour les développeurs .NET afin de créer, modifier et extraire des documents PDF au sein de leurs applications. IronPDF aide àgénérer des PDF à partir de HTMLles utilisateurs peuvent également utiliser le logiciel de gestion des PDF, modifier des PDF existants, convertir des PDF en images, et bien d'autres choses encore. Bien qu'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é virtuel avec IronPDF

L'idée derrière l'utilisation des génériques ici est de créer une méthode réutilisable qui peut générer un PDF à partir de n'importe quelle chaîne HTML donnée. Cette méthode sera générique, ce qui nous permettra de spécifier différents types de métadonnées ou de 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. Pour les besoins de la démonstration, cette classe sera basique, mais vous pouvez l'étendre avec d'autres 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

Créons maintenant une méthode statique qui génère un PDF à l'aide d'IronPDF, en tirant parti de nos PdfOptionsclasse. Cette méthode prend une instance de PdfOptionsen tant que paramètre, illustrant ainsi l'utilisation des génériques en action.

public static class PdfGenerator
{
    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}");
    }
}

public static class PdfGenerator
{
    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}");
    }
}

Public Module PdfGenerator
	Public Sub GeneratePdf(Of T)(ByVal options As PdfOptions(Of T))
		' Initialize the IronPDF HtmlToPdf renderer
		Dim 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
		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.
		Dim tempVar As Boolean = TypeOf options.Metadata Is String
		Dim metadataString As String = If(tempVar, CStr(options.Metadata), Nothing)
		If tempVar Then
			Console.WriteLine($"Metadata: {metadataString}")
		End If
		' Save the PDF to a file
		Dim fileName = $"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 peut être une chaîne de caractères contenant un titre ou toute autre information jugée pertinente.

class Program
{
    static void Main(string [] args)
    {
        License.LicenseKey = "License-Key";
        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"
        };
        PdfGenerator.GeneratePdf(options);
    }
}

class Program
{
    static void Main(string [] args)
    {
        License.LicenseKey = "License-Key";
        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"
        };
        PdfGenerator.GeneratePdf(options);
    }
}

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		License.LicenseKey = "License-Key"
		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"
		}
		PdfGenerator.GeneratePdf(options)
	End Sub
End Class

Cet exemple illustre les bases de l'intégration d'IronPDF avec C# Generics, offrant un moyen flexible de générer des PDF à partir de contenu HTML tout en permettant des métadonnées ou des configurations personnalisables par le biais de PdfOptions génériquesclasse. Vous pouvez développer ce système en ajoutant des options plus sophistiquées et des configurations de rendu en fonction des besoins de votre application.

Conclusion

La généricité en C# est un outil puissant pour développer un code de haute qualité, réutilisable et sûr. En comprenant et en appliquant les classes génériques, les méthodes, les interfaces et les délégués, vous pouvez écrire un code plus adaptable et plus facile à maintenir. Les génériques permettent non seulement la réutilisation du code à travers différents types de données, mais aussi la vérification du type au moment de la compilation, ce qui réduit les erreurs d'exécution et améliore la qualité globale du code. IronPDF offre un service deessai gratuit de ses outils de bibliothèque PDFla traduction est disponible à partir de $749.