C# Pair Class (Comment ça fonctionne pour les développeurs)
Une paire est une structure de données simple qui contient deux valeurs liées. Elle offre une manière pratique de regrouper deux éléments de données distincts. Les paires sont couramment utilisées lorsqu'une méthode doit retourner deux valeurs ou lorsqu'on travaille avec des associations clé-valeur.
En C#, les développeurs ont souvent recours à l'utilisation de tuples (Tuple<T1, T2>) pour apparier des valeurs. Cependant, les tuples sont immuables, et leurs éléments sont accessibles via des propriétés comme Item1 et Item2, ce qui peut rendre le code moins lisible lorsqu'ils sont utilisés abondamment. C'est là qu'une classe Pair personnalisée devient utile.
Si vous avez besoin d'une structure pour contenir deux objets liés et que la dissimulation des données n'est pas une priorité, vous pouvez utiliser la classe Pair dans votre code. La classe Pair n'encapsule pas ses références d'objet. Au lieu de cela, elle les expose directement à tous les codes appelants comme champs publics de classe.
Ce choix de conception permet un accès direct aux objets contenus sans le surcoût de l'encapsulation. De plus, à la fin de l'article, nous explorerons comment IronPDF for PDF Generation de Iron Software Overview peut être utilisé pour générer un document PDF.
Tuples
C# 7.0 a introduit des améliorations de syntaxe des tuples, rendant les tuples encore plus faciles à utiliser. Voici comment vous pouvez déclarer et initialiser des tuples :
// Tuple declaration
var person = (name: "John", age: 30);
// Accessing tuple elements using named properties
Console.WriteLine($"Name: {person.name}, Age: {person.age}");
// Tuple deconstruction
var (name, age) = person;
Console.WriteLine($"Name: {name}, Age: {age}");
// Tuple declaration
var person = (name: "John", age: 30);
// Accessing tuple elements using named properties
Console.WriteLine($"Name: {person.name}, Age: {person.age}");
// Tuple deconstruction
var (name, age) = person;
Console.WriteLine($"Name: {name}, Age: {age}");
' Tuple declaration
Dim person = (name:= "John", age:= 30)
' Accessing tuple elements using named properties
Console.WriteLine($"Name: {person.name}, Age: {person.age}")
' Tuple deconstruction
'INSTANT VB TODO TASK: VB has no equivalent to C# deconstruction declarations:
var(name, age) = person
Console.WriteLine($"Name: {name}, Age: {age}")
Avantages des tuples
Syntaxe concise
Les tuples vous permettent d'exprimer des structures de données complexes en utilisant une syntaxe concise sans avoir besoin de définir des classes ou des structs personnalisés.
Léger
Les tuples sont des structures de données légères, ce qui les rend adaptés aux scénarios où vous avez besoin d'un stockage temporaire ou intermédiaire des données.
Nomination implicite
Avec la syntaxe des tuples, vous pouvez nommer implicitement les éléments du tuple, améliorant la lisibilité du code et réduisant le besoin de commentaires.
Retourner plusieurs valeurs depuis des méthodes
public (int Quotient, int Remainder) Divide(int dividend, int divisor)
{
int quotient = dividend / divisor;
int remainder = dividend % divisor;
return (quotient, remainder);
}
var result = Divide(10, 3);
Console.WriteLine($"Quotient: {result.Quotient}, Remainder: {result.Remainder}");
public (int Quotient, int Remainder) Divide(int dividend, int divisor)
{
int quotient = dividend / divisor;
int remainder = dividend % divisor;
return (quotient, remainder);
}
var result = Divide(10, 3);
Console.WriteLine($"Quotient: {result.Quotient}, Remainder: {result.Remainder}");
Public Function Divide(ByVal dividend As Integer, ByVal divisor As Integer) As (Quotient As Integer, Remainder As Integer)
Dim quotient As Integer = dividend \ divisor
Dim remainder As Integer = dividend Mod divisor
Return (quotient, remainder)
End Function
Private result = Divide(10, 3)
Console.WriteLine($"Quotient: {result.Quotient}, Remainder: {result.Remainder}")
Simplification des signatures de méthode
public (string Name, string Surname) GetNameAndSurname()
{
// Retrieve name and surname from a data source
return ("John", "Doe");
}
var (name, surname) = GetNameAndSurname();
Console.WriteLine($"Name: {name}, Surname: {surname}");
public (string Name, string Surname) GetNameAndSurname()
{
// Retrieve name and surname from a data source
return ("John", "Doe");
}
var (name, surname) = GetNameAndSurname();
Console.WriteLine($"Name: {name}, Surname: {surname}");
Public Function GetNameAndSurname() As (Name As String, Surname As String)
' Retrieve name and surname from a data source
Return ("John", "Doe")
End Function
'INSTANT VB TODO TASK: VB has no equivalent to C# deconstruction declarations:
var(name, surname) = GetNameAndSurname()
Console.WriteLine($"Name: {name}, Surname: {surname}")
Regroupement de données liées
var point = (x: 10, y: 20);
var color = (r: 255, g: 0, b: 0);
var person = (name: "Alice", age: 25);
var point = (x: 10, y: 20);
var color = (r: 255, g: 0, b: 0);
var person = (name: "Alice", age: 25);
Dim point = (x:= 10, y:= 20)
Dim color = (r:= 255, g:= 0, b:= 0)
Dim person = (name:= "Alice", age:= 25)
Limitations et considérations
Bien que les tuples C# 7.0 apportent des avantages significatifs, il y a quelques limitations et considérations à garder à l'esprit :
- Les tuples sont limités en termes d'expressivité par rapport aux classes ou structs personnalisés.
- Les éléments du tuple sont accessibles en utilisant Item1, Item2, etc. quand des noms explicites ne sont pas fournis, ce qui peut réduire la lisibilité du code.
Classe personnalisée Pair
public class Pair<T1, T2>
{
public T1 First { get; set; }
public T2 Second { get; set; }
// Constructor to initialize the pair
public Pair(T1 first, T2 second)
{
First = first;
Second = second;
}
}
public class Pair<T1, T2>
{
public T1 First { get; set; }
public T2 Second { get; set; }
// Constructor to initialize the pair
public Pair(T1 first, T2 second)
{
First = first;
Second = second;
}
}
Public Class Pair(Of T1, T2)
Public Property First() As T1
Public Property Second() As T2
' Constructor to initialize the pair
Public Sub New(ByVal first As T1, ByVal second As T2)
Me.First = first
Me.Second = second
End Sub
End Class
Dans cette classe, les types sont définis au moment de l'utilisation, et les deux propriétés sont exposées en tant que propriétés publiques.
Utilisation de la classe Pair
Maintenant, explorons quelques cas d'utilisation courants où la classe Pair peut être bénéfique :
1. Stocker des coordonnées
// Creating a new instance of the Pair class to store coordinates
Pair<int, int> coordinates = new Pair<int, int>(10, 20);
Console.WriteLine($"X: {coordinates.First}, Y: {coordinates.Second}");
// Creating a new instance of the Pair class to store coordinates
Pair<int, int> coordinates = new Pair<int, int>(10, 20);
Console.WriteLine($"X: {coordinates.First}, Y: {coordinates.Second}");
' Creating a new instance of the Pair class to store coordinates
Dim coordinates As New Pair(Of Integer, Integer)(10, 20)
Console.WriteLine($"X: {coordinates.First}, Y: {coordinates.Second}")
2. Retourner plusieurs valeurs depuis une méthode
// Method returning a Pair, representing both quotient and remainder
public Pair<int, int> Divide(int dividend, int divisor)
{
int quotient = dividend / divisor;
int remainder = dividend % divisor;
return new Pair<int, int>(quotient, remainder);
}
// Usage
Pair<int, int> result = Divide(10, 3);
Console.WriteLine($"Quotient: {result.First}, Remainder: {result.Second}");
// Method returning a Pair, representing both quotient and remainder
public Pair<int, int> Divide(int dividend, int divisor)
{
int quotient = dividend / divisor;
int remainder = dividend % divisor;
return new Pair<int, int>(quotient, remainder);
}
// Usage
Pair<int, int> result = Divide(10, 3);
Console.WriteLine($"Quotient: {result.First}, Remainder: {result.Second}");
' Method returning a Pair, representing both quotient and remainder
Public Function Divide(ByVal dividend As Integer, ByVal divisor As Integer) As Pair(Of Integer, Integer)
Dim quotient As Integer = dividend \ divisor
Dim remainder As Integer = dividend Mod divisor
Return New Pair(Of Integer, Integer)(quotient, remainder)
End Function
' Usage
Private result As Pair(Of Integer, Integer) = Divide(10, 3)
Console.WriteLine($"Quotient: {result.First}, Remainder: {result.Second}")
3. Stocker des paires clé-valeur
// Storing a key-value pair
Pair<string, int> keyValue = new Pair<string, int>("Age", 30);
Console.WriteLine($"Key: {keyValue.First}, Value: {keyValue.Second}");
// Storing a key-value pair
Pair<string, int> keyValue = new Pair<string, int>("Age", 30);
Console.WriteLine($"Key: {keyValue.First}, Value: {keyValue.Second}");
' Storing a key-value pair
Dim keyValue As New Pair(Of String, Integer)("Age", 30)
Console.WriteLine($"Key: {keyValue.First}, Value: {keyValue.Second}")
Paires clé-valeur
Les paires clé-valeur offrent un moyen simple et efficace d'associer des données. En C#, l'outil principal pour travailler avec des paires clé-valeur est la classe Dictionary<TKey, TValue>, un type de collection polyvalent et puissant.
Comprendre les paires clé-valeur
Une paire clé-valeur est une structure de données qui associe une clé unique à une valeur. Cette association permet une récupération et une manipulation efficaces des données basées sur son identifiant unique. En C#, les paires clé-valeur sont couramment utilisées pour des tâches telles que la mise en cache, la gestion des configurations et le stockage des données.
Dictionary<TKey, TValue> in C
La classe Dictionary<TKey, TValue> en C# est une collection générique qui stocke des paires clé-valeur. Elle offre des recherches rapides basées sur les clés et est largement utilisée pour gérer des données associatives.
Création et hiérarchisation d'un dictionnaire
Dictionary<string, int> ages = new Dictionary<string, int>
{
{ "Alice", 30 },
{ "Bob", 35 },
{ "Charlie", 25 }
};
Dictionary<string, int> ages = new Dictionary<string, int>
{
{ "Alice", 30 },
{ "Bob", 35 },
{ "Charlie", 25 }
};
Dim ages As New Dictionary(Of String, Integer) From {
{"Alice", 30},
{"Bob", 35},
{"Charlie", 25}
}
Accès aux valeurs par clé
// Directly access a value by its key
Console.WriteLine($"Alice's age: {ages["Alice"]}");
// Directly access a value by its key
Console.WriteLine($"Alice's age: {ages["Alice"]}");
' Directly access a value by its key
Console.WriteLine($"Alice's age: {ages("Alice")}")
Itération sur les paires clé-valeur
// Iterate over all key-value pairs in the dictionary
foreach (var pair in ages)
{
Console.WriteLine($"Name: {pair.Key}, Age: {pair.Value}");
}
// Iterate over all key-value pairs in the dictionary
foreach (var pair in ages)
{
Console.WriteLine($"Name: {pair.Key}, Age: {pair.Value}");
}
' Iterate over all key-value pairs in the dictionary
For Each pair In ages
Console.WriteLine($"Name: {pair.Key}, Age: {pair.Value}")
Next pair
Scénarios avancés
Gestion des clés manquantes
if (ages.TryGetValue("David", out int age))
{
Console.WriteLine($"David's age: {age}");
}
else
{
Console.WriteLine("David's age is not available.");
}
if (ages.TryGetValue("David", out int age))
{
Console.WriteLine($"David's age: {age}");
}
else
{
Console.WriteLine("David's age is not available.");
}
Dim age As Integer
If ages.TryGetValue("David", age) Then
Console.WriteLine($"David's age: {age}")
Else
Console.WriteLine("David's age is not available.")
End If
Suppression d'entrées
// Remove an entry given its key
ages.Remove("Charlie");
// Remove an entry given its key
ages.Remove("Charlie");
' Remove an entry given its key
ages.Remove("Charlie")
Initialisation du dictionnaire
// Initialize a dictionary with color codes
var colors = new Dictionary<string, string>
{
{ "red", "#FF0000" },
{ "green", "#00FF00" },
{ "blue", "#0000FF" }
};
// Initialize a dictionary with color codes
var colors = new Dictionary<string, string>
{
{ "red", "#FF0000" },
{ "green", "#00FF00" },
{ "blue", "#0000FF" }
};
' Initialize a dictionary with color codes
Dim colors = New Dictionary(Of String, String) From {
{"red", "#FF0000"},
{"green", "#00FF00"},
{"blue", "#0000FF"}
}
Au-delà du Dictionnaire : Alternatives et Considérations
Bien que Dictionary<TKey, TValue> soit un outil puissant, les approches et considérations alternatives dépendent des exigences spécifiques de votre application :
ConcurrentDictionary<TKey, TValue>: Si votre application nécessite un accès thread-safe au dictionnaire depuis plusieurs threads, envisagez d'utiliserConcurrentDictionary<TKey, TValue>.ImmutableDictionary<TKey, TValue>: Pour les scénarios où l'immuabilité est souhaitée,ImmutableDictionary<TKey, TValue>de l'espace de nomsSystem.Collections.Immutablefournit des collections de clés-valeurs immuables.- Classes Personnalisées de Paires Clé-Valeur : Dans les situations où vous avez besoin de fonctionnalités supplémentaires ou d'un comportement spécifique, envisagez de créer des classes personnalisées de paires clé-valeur adaptées à vos besoins.
Bibliothèque IronPDF
IronPDF par Iron Software Products est une excellente bibliothèque pour générer des documents PDF. Sa facilité d'utilisation et son efficacité sont inégalées.
IronPDF excelle dans la conversion HTML en PDF, garantissant une préservation précise des mises en page et styles originaux. Il est parfait pour créer des PDF à partir de contenus basés sur le Web tels que des rapports, des factures et de la documentation. Avec le support des fichiers HTML, des URLs et des chaînes HTML brutes, IronPDF produit facilement des documents PDF de haute qualité.
using IronPdf;
class Program
{
static void Main(string[] args)
{
var renderer = new ChromePdfRenderer();
// 1. Convert HTML String to PDF
var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");
// 2. Convert HTML File to PDF
var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");
// 3. Convert URL to PDF
var url = "http://ironpdf.com"; // Specify the URL
var pdfFromUrl = renderer.RenderUrlAsPdf(url);
pdfFromUrl.SaveAs("URLToPDF.pdf");
}
}
using IronPdf;
class Program
{
static void Main(string[] args)
{
var renderer = new ChromePdfRenderer();
// 1. Convert HTML String to PDF
var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");
// 2. Convert HTML File to PDF
var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");
// 3. Convert URL to PDF
var url = "http://ironpdf.com"; // Specify the URL
var pdfFromUrl = renderer.RenderUrlAsPdf(url);
pdfFromUrl.SaveAs("URLToPDF.pdf");
}
}
Imports IronPdf
Friend Class Program
Shared Sub Main(ByVal args() As String)
Dim renderer = New ChromePdfRenderer()
' 1. Convert HTML String to PDF
Dim htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>"
Dim pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent)
pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf")
' 2. Convert HTML File to PDF
Dim htmlFilePath = "path_to_your_html_file.html" ' Specify the path to your HTML file
Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")
' 3. Convert URL to PDF
Dim url = "http://ironpdf.com" ' Specify the URL
Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
pdfFromUrl.SaveAs("URLToPDF.pdf")
End Sub
End Class
IronPDF peut être installé à partir du gestionnaire de packages NuGet :
Install-Package IronPdf
Ou depuis Visual Studio de cette manière :

Pour générer un document avec un exemple de tuple, nous pouvons utiliser le code suivant :
using IronPdf;
namespace IronPatterns
{
class Program
{
static void Main()
{
Console.WriteLine("-----------Iron Software-------------");
var renderer = new ChromePdfRenderer(); // var pattern
var content = "<h1>Iron Software is Awesome</h1> Made with IronPDF!";
content += "<h2>Demo C# Pair with Tuples</h2>";
var result = Divide(10, 3);
Console.WriteLine($"Quotient: {result.Item1}, Remainder: {result.Item2}");
content += $"<p>When we divide 10 by 3:</p>";
content += $"<p>Quotient: {result.Item1}, Remainder: {result.Item2}</p>";
var pdf = renderer.RenderHtmlAsPdf(content);
pdf.SaveAs("output.pdf"); // Saves PDF
}
// Method to demonstrate division using tuples
public static (int Quotient, int Remainder) Divide(int dividend, int divisor)
{
int quotient = dividend / divisor;
int remainder = dividend % divisor;
return (quotient, remainder);
}
}
}
using IronPdf;
namespace IronPatterns
{
class Program
{
static void Main()
{
Console.WriteLine("-----------Iron Software-------------");
var renderer = new ChromePdfRenderer(); // var pattern
var content = "<h1>Iron Software is Awesome</h1> Made with IronPDF!";
content += "<h2>Demo C# Pair with Tuples</h2>";
var result = Divide(10, 3);
Console.WriteLine($"Quotient: {result.Item1}, Remainder: {result.Item2}");
content += $"<p>When we divide 10 by 3:</p>";
content += $"<p>Quotient: {result.Item1}, Remainder: {result.Item2}</p>";
var pdf = renderer.RenderHtmlAsPdf(content);
pdf.SaveAs("output.pdf"); // Saves PDF
}
// Method to demonstrate division using tuples
public static (int Quotient, int Remainder) Divide(int dividend, int divisor)
{
int quotient = dividend / divisor;
int remainder = dividend % divisor;
return (quotient, remainder);
}
}
}
Imports IronPdf
Namespace IronPatterns
Friend Class Program
Shared Sub Main()
Console.WriteLine("-----------Iron Software-------------")
Dim renderer = New ChromePdfRenderer() ' var pattern
Dim content = "<h1>Iron Software is Awesome</h1> Made with IronPDF!"
content &= "<h2>Demo C# Pair with Tuples</h2>"
Dim result = Divide(10, 3)
Console.WriteLine($"Quotient: {result.Item1}, Remainder: {result.Item2}")
content &= $"<p>When we divide 10 by 3:</p>"
content &= $"<p>Quotient: {result.Item1}, Remainder: {result.Item2}</p>"
Dim pdf = renderer.RenderHtmlAsPdf(content)
pdf.SaveAs("output.pdf") ' Saves PDF
End Sub
' Method to demonstrate division using tuples
Public Shared Function Divide(ByVal dividend As Integer, ByVal divisor As Integer) As (Quotient As Integer, Remainder As Integer)
Dim quotient As Integer = dividend \ divisor
Dim remainder As Integer = dividend Mod divisor
Return (quotient, remainder)
End Function
End Class
End Namespace
Sortie

Licence d'essai pour IronPDF
Obtenez votre licence d'essai IronPDF et placez la licence dans le appsettings.json.
{
"IronPdf.LicenseKey": "<Your Key>"
}
Conclusion
Dans cet article, nous avons exploré le concept de paires et l'importance d'avoir une classe Pair en C#. Nous avons fourni une implémentation simple de la classe personnalisée Pair ainsi que divers cas d'utilisation démontrant sa polyvalence et son utilité dans les tâches de programmation quotidiennes.
Que vous travailliez avec des coordonnées, en renvoyant plusieurs valeurs depuis une méthode, ou en stockant des associations clé-valeur, la classe Pair peut être un ajout précieux à votre ensemble de compétences en programmation.
En plus de cela, la fonctionnalité de la bibliothèque IronPDF est un excellent ensemble de compétences à posséder pour que les développeurs génèrent des documents PDF à la volée selon les besoins dans les applications.
Questions Fréquemment Posées
Qu'est-ce qu'une classe Pair en C# ?
Une classe Pair en C# est une structure de données simple conçue pour contenir deux valeurs liées. Elle permet un accès direct à ses propriétés en tant que champs publics, ce qui en fait une alternative pratique aux tuples quand l'encapsulation n'est pas une priorité.
Comment la classe Pair diffère-t-elle d'un Tuple en C# ?
La classe Pair diffère d'un Tuple en ce qu'elle expose directement ses références d'objets via des champs publics, améliorant la lisibilité et la flexibilité. Les tuples, en revanche, sont immuables et accèdent à leurs éléments via des propriétés comme Item1 et Item2.
Quels sont les avantages d'utiliser la classe Pair par rapport aux tuples ?
Les avantages d'utiliser la classe Pair par rapport aux tuples comprennent une lisibilité améliorée du code en utilisant des noms de propriété descriptifs au lieu de Item1 et Item2, et la possibilité de modifier les valeurs, les Pairs étant mutables.
Puis-je utiliser la classe Pair pour stocker des paires clé-valeur ?
Oui, la classe Pair est particulièrement utile pour stocker des paires clé-valeur de manière plus lisible par rapport aux tuples, grâce à son accès direct aux valeurs via des champs publics.
Quels sont les scénarios courants d'utilisation de la classe Pair en C# ?
Les scénarios courants d'utilisation de la classe Pair incluent le stockage de coordonnées, le retour de plusieurs valeurs d'une méthode, et la gestion des associations de paires clé-valeur dans un format lisible.
Pourquoi un développeur choisirait-il d'utiliser la bibliothèque IronPDF ?
Un développeur pourrait choisir d'utiliser la bibliothèque IronPDF pour générer des PDFs à partir de contenu HTML. Elle garantit la préservation de la mise en page et du style d'origine, simplifiant la création de documents professionnels tels que les rapports et les factures.
Comment puis-je générer un PDF à partir d'un fichier HTML en C# ?
Vous pouvez générer un PDF à partir d'un fichier HTML en C# en utilisant la bibliothèque IronPDF. Elle propose des méthodes telles que RenderHtmlAsPdf pour convertir des chaînes HTML et des fichiers en documents PDF de haute qualité.
Quel est l'avantage d'utiliser une bibliothèque pour la génération de PDFs ?
Utiliser une bibliothèque comme IronPDF pour la génération de PDFs offre des processus simplifiés pour créer des documents PDF de haute qualité, assurant la préservation précise de la mise en page et du style à partir de diverses sources de contenu.
Quel rôle jouent la classe Pair et la bibliothèque IronPDF dans l'outillage d'un développeur ?
La classe Pair et la bibliothèque IronPDF améliorent l'outillage d'un développeur en fournissant une gestion efficace des structures de données avec les Pairs et des capacités de génération documentaire fiables avec IronPDF, les rendant précieux pour gérer des données complexes et des flux de documents.




