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 recourent souvent à l'utilisation des tuples (Tuple<T1, T2>) pour associer 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.
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
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}")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.
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.
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.
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}")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}")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)Bien que les tuples C# 7.0 apportent des avantages significatifs, il y a quelques limitations et considérations à garder à l'esprit :
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 ClassDans 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.
Maintenant, explorons quelques cas d'utilisation courants où la classe Pair peut être bénéfique :
// 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}")// 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}")// 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}")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.
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.
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}
}// 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")}")// 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 pairif (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// Remove an entry given its key
ages.Remove("Charlie");' Remove an entry given its key
ages.Remove("Charlie")// 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"}
}Bien que Dictionary<TKey, TValue> soit un outil puissant, des approches alternatives et des considérations 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'utiliser ConcurrentDictionary<TKey, TValue>.ImmutableDictionary<TKey, TValue> : Pour les scénarios où l'immuabilité est souhaitée, ImmutableDictionary<TKey, TValue> du namespace System.Collections.Immutable fournit des collections clé-valeur immuables.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");
}
}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 ClassIronPDF peut être installé à partir du gestionnaire de packages NuGet :
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);
}
}
}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
Obtenez votre Licence d'essai IronPDF et placez la licence dans le appsettings.json.
{
"IronPdf.LicenseKey": "<Your Key>"
}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.
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.
IronPDF fait partie de IRONSUITE
10 API .NET pour vos documents
Lorsque vous avez besoin que votre PDF ressemble à HTML, rapidement.
