Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. .NET Aide
  4. Classe Pair C#
.NET AIDE

C# Pair Class (Comment ça fonctionne pour les développeurs)

Jacob Mellor, Directeur technique @ Team Iron
Jacob Mellor
Mis à jour:

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 aux 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.

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}");
$vbLabelText   $csharpLabel

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}");
$vbLabelText   $csharpLabel

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}");
$vbLabelText   $csharpLabel

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);
$vbLabelText   $csharpLabel

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;
    }
}
$vbLabelText   $csharpLabel

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}");
$vbLabelText   $csharpLabel

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}");
$vbLabelText   $csharpLabel

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}");
$vbLabelText   $csharpLabel

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 les paires clé-valeur est la classe Dictionary<TKey, TValue>, un type de collection versatile 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> en C#

La classe Dictionary<TKey, TValue> en C# est une collection générique qui stocke les 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 }
};
$vbLabelText   $csharpLabel

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"]}");
$vbLabelText   $csharpLabel

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}");
}
$vbLabelText   $csharpLabel

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.");
}
$vbLabelText   $csharpLabel

Suppression d'Entrées

// Remove an entry given its key
ages.Remove("Charlie");
// Remove an entry given its key
ages.Remove("Charlie");
$vbLabelText   $csharpLabel

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" }
};
$vbLabelText   $csharpLabel

Au-delà du Dictionnaire : Alternatives et Considérations

Bien que Dictionary<TKey, TValue> soit un outil puissant, les approches alternatives 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 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 offre des collections clé-valeur 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");
    }
}
$vbLabelText   $csharpLabel

IronPDF peut être installé à partir du gestionnaire de packages NuGet :

Install-Package IronPdf

Ou depuis Visual Studio de cette manière :

Classe Pair C# (Fonctionnement Pour Les Développeurs) : Figure 1 - Installation de IronPDF avec le gestionnaire de packages NuGet

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);
        }
    }
}
$vbLabelText   $csharpLabel

Sortie

Classe Pair C# (Fonctionnement Pour Les Développeurs) : Figure 2

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.

Jacob Mellor, Directeur technique @ Team Iron
Jacob Mellor
  Discutez maintenant avec l'équipe d'ingénierie
Directeur technique

Jacob Mellor est directeur technique chez Iron Software et un ingénieur visionnaire pionnier dans la technologie des PDF en C#. En tant que développeur original derrière la base de code principale d'Iron Software, il a façonné l'architecture du produit de l'entreprise depuis sa création, ...

Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Essai gratuit