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");
Génériques C# (Comment ça marche pour les développeurs)
Regan Pun
avril 3, 2024
Partager:
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
$vbLabelText $csharpLabel
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")
$vbLabelText $csharpLabel
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
$vbLabelText $csharpLabel
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)
$vbLabelText $csharpLabel
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
$vbLabelText $csharpLabel
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)
$vbLabelText $csharpLabel
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")
$vbLabelText $csharpLabel
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
$vbLabelText $csharpLabel
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
$vbLabelText $csharpLabel
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
$vbLabelText $csharpLabel
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
$vbLabelText $csharpLabel
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.
Regan est diplômé de l'université de Reading, où il a obtenu une licence en ingénierie électronique. Avant de rejoindre Iron Software, il s'était concentré sur une seule tâche. Ce qu'il apprécie le plus chez Iron Software, c'est la diversité des tâches qu'il peut accomplir, qu'il s'agisse d'apporter une valeur ajoutée aux ventes, à l'assistance technique, au développement de produits ou à la commercialisation. Il aime comprendre comment les développeurs utilisent la bibliothèque d'Iron Software et utiliser ces connaissances pour améliorer continuellement la documentation et développer les produits.
< PRÉCÉDENT C# String.Join (Comment ça marche pour les développeurs)
SUIVANT > Mot-clé virtuel C# (comment il fonctionne pour les développeurs)
Des millions d'ingénieurs dans le monde entier lui font confiance
Réservez une démo en direct gratuite
Réservez une démonstration personnelle de 30 minutes.
Pas de contrat, pas de détails de carte, pas d'engagements.
Voici ce à quoi vous pouvez vous attendre :
Une démonstration en direct de notre produit et de ses principales fonctionnalités
Obtenez des recommandations de fonctionnalités spécifiques au projet
Toutes vos questions trouvent réponse pour vous assurer de disposer de toutes les informations dont vous avez besoin. (Aucun engagement de votre part.)
CHOISIR L'HEURE
VOS INFORMATIONS
Réservez votre démo en direct gratuite
Fiable par plus de 2 millions d'ingénieurs dans le monde entier