AIDE .NET

Classe de paires C# (Comment ça marche pour les développeurs)

Regan Pun

juin 6, 2024

Introduction

Une paire est une structure de données simple qui contient deux valeurs liées. Il s'agit d'un moyen pratique de regrouper deux données distinctes. Les paires sont couramment utilisées lorsqu'une méthode doit renvoyer deux valeurs ou lorsqu'on travaille avec des associations clé-valeur.

En C#, les développeurs ont souvent recours aux tuples(Tuple<T1, T2>) pour les valeurs d'appariement. Cependant, les tuples sont immuables et leurs éléments sont accessibles via des propriétés telles que Item1 et Item2, ce qui peut conduire à un code moins lisible en cas d'utilisation intensive. C'est là qu'une classe Pair personnalisée s'avère utile.

Si vous avez besoin d'une structure pour contenir deux objets liés et que le masquage 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'objets. Au lieu de cela, il les expose directement à tous les codes d'appel en tant que champs de classe publics.

Ce choix de conception permet un accès direct aux objets contenus sans les inconvénients de l'encapsulation. En outre, à la fin de l'article, nous examinerons commentIronPDF pour la génération de PDF dePrésentation du logiciel Iron Software peut être utilisé pour générer un document PDF.

Tuples

C# 7.0 a apporté des améliorations à la syntaxe des n-uplets, ce qui rend leur utilisation encore plus facile. Voici comment déclarer et initialiser les tuples :

// Tuple declaration
var person = (name: "John", age: 30);
// Accessing tuple elements
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
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
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 permettent d'exprimer des structures de données complexes à l'aide d'une syntaxe concise, sans qu'il soit nécessaire de définir des classes ou des structures personnalisées.

Léger

Les tuples sont des structures de données légères, qui conviennent aux scénarios dans lesquels vous avez besoin d'un stockage temporaire ou intermédiaire des données.

Désignation implicite

La syntaxe tuple permet de nommer implicitement les éléments tuple, ce qui améliore la lisibilité du code et réduit le besoin de commentaires.

Retourner des valeurs multiples à partir de méthodes

public (int, int) 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.Item1}, Remainder: {result.Item2}");

public (int, int) 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.Item1}, Remainder: {result.Item2}");

Public Function Divide(ByVal dividend As Integer, ByVal divisor As Integer) As (Integer, 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.Item1}, Remainder: {result.Item2}")

Simplifier les signatures de méthode

public (string, string) GetNameAndSurname()
{
    // Retrieve name and surname from a data source
    return ("John", "Doe");
}
var (name, surname) = GetNameAndSurname();
Console.WriteLine($"Name: {name}, Surname: {surname}");

public (string, string) 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 (String, 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 connexes

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)

Limites et considérations

Bien que les tuples C# 7.0 offrent des avantages significatifs, il convient de garder à l'esprit certaines limitations et considérations :

Les tuples sont limités en termes d'expressivité par rapport aux classes personnalisées ou aux structures.
Les éléments d'un tuple sont accessibles en utilisant Item1, Item2, etc. lorsque des noms explicites ne sont pas fournis, ce qui peut réduire la lisibilité du code.

Paire de classes personnalisées

public class Pair<T1, T2>
{
    public T1 First { get; set; }
    public T2 Second { get; set; }
    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; }
    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
	Public Sub New(ByVal first As T1, ByVal second As T2)
		Me.First = first
		Me.Second = second
	End Sub
End Class

Ici, 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

Dans l'exemple suivant, nous allons explorer quelques cas d'utilisation courants pour lesquels la classe Pair peut être utile :

1. Stockage des coordonnées

Pair<int, int> coordinates = new Pair<int, int>(10, 20); // new instance
Console.WriteLine($"X: {coordinates.First}, Y: {coordinates.Second}");

Pair<int, int> coordinates = new Pair<int, int>(10, 20); // new instance
Console.WriteLine($"X: {coordinates.First}, Y: {coordinates.Second}");

Dim coordinates As New Pair(Of Integer, Integer)(10, 20) ' new instance
Console.WriteLine($"X: {coordinates.First}, Y: {coordinates.Second}")

2. Retourner plusieurs valeurs à partir d'une méthode

public Pair<int, int> Divide(int dividend, int divisor)
{
    int quotient = dividend / divisor;
    int remainder = dividend % divisor;
    return new Pair<int, int>(quotient, remainder);
}
Pair<int, int> result = Divide(10, 3);
Console.WriteLine($"Quotient: {result.First}, Remainder: {result.Second}");

public Pair<int, int> Divide(int dividend, int divisor)
{
    int quotient = dividend / divisor;
    int remainder = dividend % divisor;
    return new Pair<int, int>(quotient, remainder);
}
Pair<int, int> result = Divide(10, 3);
Console.WriteLine($"Quotient: {result.First}, Remainder: {result.Second}");

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
Private result As Pair(Of Integer, Integer) = Divide(10, 3)
Console.WriteLine($"Quotient: {result.First}, Remainder: {result.Second}")

3. Stockage des paires clé-valeur

Pair<string, int> keyValue = new Pair<string, int>("Age", 30);
Console.WriteLine($"Key: {keyValue.First}, Value: {keyValue.Second}");

Pair<string, int> keyValue = new Pair<string, int>("Age", 30);
Console.WriteLine($"Key: {keyValue.First}, Value: {keyValue.Second}");

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 constituent 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 d'extraire et de manipuler efficacement les données sur la base de leur identifiant unique. En C#, les paires clé-valeur sont couramment utilisées pour des tâches telles que la mise en cache, la gestion de la configuration et le stockage des données.

`Dictionary<TKey, TValue>` dans C&num ;

La classe Dictionary<TKey, TValue> en C# est une collection générique qui stocke des paires clé-valeur. Il permet des recherches rapides basées sur les clés et est largement utilisé pour la gestion des données associatives.

Création et alimentation d'un dictionnaire

Dictionary<string, int> ages = new Dictionary<string, int>();
ages["Alice"] = 30;
ages["Bob"] = 35;
ages["Charlie"] = 25;

Dictionary<string, int> ages = new Dictionary<string, int>();
ages["Alice"] = 30;
ages["Bob"] = 35;
ages["Charlie"] = 25;

Dim ages As New Dictionary(Of String, Integer)()
ages("Alice") = 30
ages("Bob") = 35
ages("Charlie") = 25

Accès aux valeurs par clé

Console.WriteLine($"Alice's age: {ages["Alice"]}");

Console.WriteLine($"Alice's age: {ages["Alice"]}");

Console.WriteLine($"Alice's age: {ages("Alice")}")

Itération sur les paires clé-valeur

foreach (var pair in ages)
{
    Console.WriteLine($"Name: {pair.Key}, Age: {pair.Value}");
}

foreach (var pair in ages)
{
    Console.WriteLine($"Name: {pair.Key}, Age: {pair.Value}");
}

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

ages.Remove("Charlie");

ages.Remove("Charlie");

ages.Remove("Charlie")

Initialisation du dictionnaire

var colors = new Dictionary<string, string>
{
    { "red", "#FF0000" },
    { "green", "#00FF00" },
    { "blue", "#0000FF" }
};

var colors = new Dictionary<string, string>
{
    { "red", "#FF0000" },
    { "green", "#00FF00" },
    { "blue", "#0000FF" }
};

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, d'autres approches et 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 à partir de plusieurs threads, envisagez d'utiliser ConcurrentDictionary<TKey, TValue>.
ImmutableDictionary<TKey, TValue>: Pour les scénarios où l'immutabilité est souhaitée, ImmutableDictionary<TKey, TValue> de l'espace de noms System.Collections.Immutable fournit des collections clé-valeur immuables.
Classes de paires clé-valeur personnalisées : Lorsque vous avez besoin de fonctionnalités supplémentaires ou d'un comportement spécifique, vous pouvez envisager de créer des classes de paires clé-valeur personnalisées, 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 les domaines suivantsHTML vers PDFconversion, garantissant une préservation précise des mises en page et des styles originaux. C'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 la prise en charge des fichiers HTML, des URL 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 paquets NuGet :

Install-Package IronPdf

Ou à partir de Visual Studio, comme suit :

Classe de paires C# (Comment ça marche pour les développeurs) : Figure 1 - Installation d'IronPDF avec le gestionnaire de paquets NuGet

Pour générer un document avec un exemple de tuple, nous pouvons utiliser le code suivant :

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, 3 </p>";
        content += $"<p>Quotient: {result.Item1}, Remainder: {result.Item2}</p>";
        var pdf = renderer.RenderHtmlAsPdf(content);
        pdf.SaveAs("output.pdf"); // Saves PDF        
    }
    public static (int, int) Divide(int dividend, int divisor)
    {
        // var count;
        int quotient = dividend / divisor;
        int remainder = dividend % divisor;
        return (quotient, remainder);
    }
}

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, 3 </p>";
        content += $"<p>Quotient: {result.Item1}, Remainder: {result.Item2}</p>";
        var pdf = renderer.RenderHtmlAsPdf(content);
        pdf.SaveAs("output.pdf"); // Saves PDF        
    }
    public static (int, int) Divide(int dividend, int divisor)
    {
        // var count;
        int quotient = dividend / divisor;
        int remainder = dividend % divisor;
        return (quotient, remainder);
    }
}

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, 3 </p>"
			content &= $"<p>Quotient: {result.Item1}, Remainder: {result.Item2}</p>"
			Dim pdf = renderer.RenderHtmlAsPdf(content)
			pdf.SaveAs("output.pdf") ' Saves PDF
		End Sub
		Public Shared Function Divide(ByVal dividend As Integer, ByVal divisor As Integer) As (Integer, Integer)
			' var count;
			Dim quotient As Integer = dividend \ divisor
			Dim remainder As Integer = dividend Mod divisor
			Return (quotient, remainder)
		End Function
	End Class
End Namespace

Sortie

Classe de paires C# (Comment ça marche pour les développeurs) : Figure 2

Licence d'essai pour IronPDF

Obtenez votreLicence d'essai d'IronPDF et placez la licence dans le fichier appsettings.json.

"IronPDF.LicenseKey": "<Your Key>"

"IronPDF.LicenseKey": "<Your Key>"

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'"IronPDF.LicenseKey": "<Your Key>"

Conclusion

Dans cet article, nous avons exploré le concept des 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, que vous renvoyiez plusieurs valeurs à partir d'une méthode ou que vous stockiez des associations clé-valeur, la classe Pair peut être un complément précieux à vos compétences en matière de programmation.

En outre, leFonctionnalité de la bibliothèque IronPDF l'utilisation d'outils de développement est une excellente combinaison de compétences pour les développeurs qui génèrent des documents PDF à la volée, en fonction des besoins des applications.

Regan Pun

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

Ingénieur logiciel

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
Mot-clé interne C# (Comment ça marche pour les développeurs)

SUIVANT >
Dapper C# (Comment ça marche pour les développeurs)