.NET AYUDA

C# Pair Class (Cómo Funciona para Desarrolladores)

Actualizado:julio 28, 2025

Un par es una estructura de datos simple que contiene dos valores relacionados. Proporciona una forma conveniente de empaquetar dos piezas distintas de datos juntas. Los pares se usan comúnmente cuando un método necesita devolver dos valores o cuando se trabaja con asociaciones clave-valor.

En C#, los desarrolladores a menudo recurren a usar tuplas (Tuple<T1, T2>) para emparejar valores. Sin embargo, las tuplas son inmutables y sus elementos se acceden a través de propiedades como Item1 y Item2, lo que puede llevar a un código menos legible cuando se usan extensamente. Aquí es donde una clase Pair personalizada es útil.

Si necesitas una estructura para contener dos objetos relacionados y el ocultamiento de datos no es una prioridad, puedes utilizar la clase Pair en tu código. La clase Pair no encapsula sus referencias a objetos. En cambio, las expone directamente a todos los códigos que llaman como campos de clase pública.

Esta opción de diseño permite un acceso directo a los objetos contenidos sin la sobrecarga de la encapsulación. Además, al final del artículo, exploraremos cómo IronPDF para la generación de PDF de Iron Software Overview se puede usar para generar un documento PDF.

Tuplas

C# 7.0 introdujo mejoras en la sintaxis de tuplas, haciendo que las tuplas sean aún más fáciles de trabajar. Aquí está cómo se pueden declarar e inicializar tuplas:

// 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

Beneficios de las tuplas

Sintaxis concisa

Las tuplas te permiten expresar estructuras de datos complejas utilizando una sintaxis concisa sin necesidad de definir clases o estructuras personalizadas.

Ligero

Las tuplas son estructuras de datos ligeras, lo que las hace adecuadas para escenarios donde necesitas almacenamiento temporal o intermedio de datos.

Nombres implícitos

Con la sintaxis de tuplas, puedes nombrar implícitamente los elementos de la tupla, mejorando la legibilidad del código y reduciendo la necesidad de comentarios.

Retorno de múltiples valores desde métodos

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

Simplificación de las firmas de métodos

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

Agrupación de datos relacionados

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

Limitaciones y consideraciones

Mientras que las tuplas de C# 7.0 ofrecen beneficios significativos, hay algunas limitaciones y consideraciones a tener en cuenta:

Las tuplas están limitadas en términos de expresividad en comparación con las clases o estructuras personalizadas.
Los elementos de la tupla se acceden utilizando Item1, Item2, etc., cuando no se proporcionan nombres explícitos, lo que puede reducir la legibilidad del código.

Clase personalizada Par

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

En esta clase, los tipos se definen en el momento del uso, y las dos propiedades se exponen como propiedades públicas.

Uso de la clase Pair

Ahora, exploremos algunos casos de uso comunes donde la clase Pair puede ser beneficiosa:

1. Almacenamiento de coordenadas

// 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. Devolución de múltiples valores desde un método

// 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. Almacenamiento de pares clave-valor

// 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

Pares clave-valor

Los pares clave-valor proporcionan una forma simple y eficiente de asociar datos. En C#, la herramienta principal para trabajar con pares clave-valor es la clase Dictionary<TKey, TValue>, un tipo de colección versátil y poderoso.

Comprensión de los pares clave-valor

Un par clave-valor es una estructura de datos que asocia una clave única con un valor. Esta asociación permite una recuperación y manipulación eficiente de datos basada en su identificador único. En C#, los pares clave-valor se utilizan comúnmente para tareas como almacenamiento en caché, gestión de configuración y almacenamiento de datos.

`Dictionary<TKey, TValue>` en C#

La clase Dictionary<TKey, TValue> en C# es una colección genérica que almacena pares clave-valor. Proporciona búsquedas rápidas basadas en las claves y se utiliza ampliamente para gestionar datos asociativos.

Crear y rellenar un diccionario

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

Acceso a valores por clave

// 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

Iteración de pares clave-valor

// 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

Escenarios avanzados

Manejo de claves perdidas

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

Eliminación de entradas

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

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

$vbLabelText $csharpLabel

Inicialización del diccionario

// 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

Más allá del diccionario: Alternativas y consideraciones

Mientras que Dictionary<TKey, TValue> es una herramienta poderosa, los enfoques alternativos y consideraciones dependen de los requisitos específicos de tu aplicación:

ConcurrentDictionary<TKey, TValue>: Si tu aplicación requiere acceso seguro por hilos al diccionario desde múltiples hilos, considera usar ConcurrentDictionary<TKey, TValue>.
ImmutableDictionary<TKey, TValue>: Para escenarios donde se desea inmutabilidad, ImmutableDictionary<TKey, TValue> del espacio de nombres System.Collections.Immutable proporciona colecciones clave-valor inmutables.
Clases Personalizadas de Pares Clave-Valor: En situaciones donde necesitas funcionalidad adicional o comportamiento específico, considera crear clases personalizadas de pares clave-valor ajustadas a tus requisitos.

Biblioteca IronPDF

IronPDF by Iron Software Products es una excelente biblioteca para generar documentos PDF. Su facilidad de uso y eficiencia son inigualables.

IronPDF se destaca en la conversión de HTML a PDF, asegurando la preservación precisa de los diseños y estilos originales. Es perfecto para crear PDFs a partir de contenido basado en la web como informes, facturas y documentación. Con soporte para archivos HTML, URLs y cadenas HTML en bruto, IronPDF produce fácilmente documentos PDF de alta calidad.

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 puede ser instalado desde el administrador de paquetes NuGet:

Install-Package IronPdf

O desde Visual Studio de esta manera:

Clase Pair C#: Figura 1 - Instalando IronPDF con el administrador de paquetes NuGet

Para generar un documento con un ejemplo de tupla, podemos usar el siguiente código:

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

Producción

Clase Pair C#: Figura 2

Licencia de prueba para IronPDF

Obtén tu Licencia de Prueba de IronPDF y coloca la licencia en el appsettings.json.

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

Conclusión

En este artículo, hemos explorado el concepto de pares y la importancia de tener una clase Pair en C#. Hemos proporcionado una implementación simple de la clase personalizada Pair junto con varios casos de uso que demuestran su versatilidad y utilidad en las tareas de programación diarias.

Ya sea que estés trabajando con coordenadas, devolviendo múltiples valores de un método o almacenando asociaciones clave-valor, la clase Pair puede ser una adición valiosa a tu conjunto de habilidades de programación.

Además de esto, la funcionalidad de la biblioteca IronPDF es un gran conjunto de habilidades para tener para los desarrolladores para generar documentos PDF al instante según se requiera en las aplicaciones.

Preguntas Frecuentes

¿Qué es una clase Pair en C#?

Una clase Pair en C# es una estructura de datos sencilla diseñada para contener dos valores relacionados. Permite un acceso directo a sus propiedades como campos públicos, lo que la convierte en una alternativa conveniente a las tuplas cuando la encapsulación no es una prioridad.

¿En qué se diferencia la clase Pair de una Tupla en C#?

La clase Pair se diferencia de una Tupla en que expone sus referencias de objetos directamente a través de campos públicos, mejorando la legibilidad y flexibilidad. Las tuplas, por otro lado, son inmutables y acceden a sus elementos a través de propiedades como Item1 y Item2.

¿Cuáles son las ventajas de usar la clase Pair sobre las tuplas?

Las ventajas de usar la clase Pair sobre las tuplas incluyen una mejor legibilidad del código al usar nombres descriptivos de las propiedades en lugar de Item1 y Item2, y la capacidad de modificar los valores ya que los Pairs son mutables.

¿Puedo usar la clase Pair para almacenar pares clave-valor?

Sí, la clase Pair es particularmente útil para almacenar pares clave-valor de una manera más legible en comparación con las tuplas, debido a su acceso directo a los valores a través de campos públicos.

¿Cuáles son algunos escenarios comunes para usar la clase Pair en C#?

Los escenarios comunes para usar la clase Pair incluyen almacenar coordenadas, devolver múltiples valores desde un método y gestionar asociaciones de pares clave-valor en un formato legible.

¿Por qué un desarrollador elegiría usar la biblioteca IronPDF?

Un desarrollador podría elegir usar la biblioteca IronPDF para generar PDFs a partir de contenido HTML. Asegura que se conserven el diseño y estilo original, simplificando la creación de documentos profesionales como informes y facturas.

¿Cómo puedo generar un PDF desde un archivo HTML en C#?

Puedes generar un PDF desde un archivo HTML en C# usando la biblioteca IronPDF. Proporciona métodos como RenderHtmlAsPdf para convertir cadenas y archivos HTML en documentos PDF de alta calidad.

¿Cuál es el beneficio de usar una biblioteca para la generación de PDF?

Usar una biblioteca como IronPDF para la generación de PDFs ofrece procesos simplificados para crear documentos PDF de alta calidad, asegurando una preservación precisa del diseño y estilo de varias fuentes de contenido.

¿Qué roles juegan la clase Pair y la biblioteca IronPDF en el kit de herramientas de un desarrollador?

La clase Pair y la biblioteca IronPDF mejoran el kit de herramientas de un desarrollador al proporcionar una gestión eficiente de estructuras de datos con Pairs y capacidades confiables de generación de documentos con IronPDF, haciéndolos valiosos para manejar datos complejos y flujos de trabajo de documentos.

Jacob Mellor

Chatea con el equipo de ingeniería ahora

Director de Tecnología

Jacob Mellor es Director de Tecnología en Iron Software y un ingeniero visionario que lidera la tecnología PDF en C#. Como el desarrollador original detrás de la base de código central de Iron Software, ha moldeado la arquitectura de productos de la compañía desde ...