C# Pair Class (Cómo funciona para los desarrolladores)

Introducción

Un par es una estructura de datos simple que contiene dos valores relacionados. Es una forma cómoda de agrupar dos datos distintos. Los pares se suelen utilizar cuando un método debe devolver dos valores o cuando se trabaja con asociaciones clave-valor.

En C#, los desarrolladores recurren a menudo al uso de tuplas(Tupla<T1, T2>) para los valores de emparejamiento. Sin embargo, las tuplas son inmutables, y se accede a sus elementos a través de propiedades como Item1 y Item2, lo que puede dar lugar a un código menos legible cuando se utiliza ampliamente. Aquí es donde resulta útil una clase Pair personalizada.

Si necesita una estructura que contenga dos objetos relacionados y la ocultación de datos no es una prioridad, puede utilizar la clase Pair en su código. La clase Par no encapsula sus referencias a objetos. En su lugar, los expone directamente a todos los códigos de llamada como campos públicos de clase.

Esta elecció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ómoIronPDF para la generación de PDF deVisión general de Iron Software puede utilizarse para generar un documento PDF.

Tuplas

C# 7.0 ha introducido mejoras en la sintaxis de las tuplas, lo que facilita aún más el trabajo con ellas. A continuación se explica cómo declarar e inicializar tuplas:

// 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}")

Ventajas de las tuplas

Sintaxis concisa

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

Ligero

Las tuplas son estructuras de datos ligeras, lo que las hace adecuadas para situaciones en las que se necesita un almacenamiento temporal o intermedio de los datos.

Nombres implícitos

Con la sintaxis de tupla, puedes nombrar implícitamente los elementos de la tupla, lo que mejora la legibilidad del código y reduce la necesidad de comentarios.

Devolución de múltiples valores por métodos

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}")

Simplificación de las firmas de métodos

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}")

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);

Dim point = (x:= 10, y:= 20)
Dim color = (r:= 255, g:= 0, b:= 0)
Dim person = (name:= "Alice", age:= 25)

Limitaciones y consideraciones

Aunque las tuplas de C# 7.0 ofrecen importantes ventajas, hay que tener en cuenta algunas limitaciones y consideraciones:

• Las tuplas están limitadas en términos de expresividad en comparación con las clases personalizadas o los structs.
• Se accede a los elementos de la tupla utilizando Elemento1, Elemento2, etc. cuando no se proporcionan nombres explícitos, lo que puede reducir la legibilidad del código.

Emparejar clase personalizada

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

Aquí los tipos se definen en el momento del uso y las dos propiedades se exponen como propiedades públicas.

Utilización de la clase Par

Ahora, exploremos algunos casos de uso común en el siguiente ejemplo donde la clase Pair puede ser beneficiosa:

1. Almacenamiento de coordenadas

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

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

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}")

Pares clave-valor

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

Pares clave-valor

Un par clave-valor es una estructura de datos que asocia una clave única a un valor. Esta asociación permite recuperar y manipular eficazmente los datos a partir de su identificador único. En C#, los pares clave-valor se utilizan habitualmente para tareas como el almacenamiento en caché, la gestión de la configuración y el 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>();
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

Acceso a los valores por clave

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

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

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

Iteración de pares clave-valor

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

Escenarios avanzados

Gestión de llaves 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.");
}

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

Eliminar entradas

ages.Remove("Charlie");

ages.Remove("Charlie");

ages.Remove("Charlie")

Inicialización del diccionario

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"}
}

Más allá del diccionario: Alternativas y consideraciones

Aunque Dictionary<TKey, TValue> es una herramienta potente, los enfoques y consideraciones alternativos dependen de los requisitos específicos de su aplicación:

• ConcurrentDictionary<TKey, TValue>: Si su aplicación requiere un acceso seguro al diccionario desde varios subprocesos, considere el uso de ConcurrentDictionary<TKey, TValue>.
• ImmutableDictionary<TKey, TValue>: Para escenarios en los que se desea inmutabilidad, ImmutableDictionary<TKey, TValue> del espacio de nombres System.Collections.Immutable proporciona colecciones clave-valor inmutables.
• Clases personalizadas de par clave-valor: En situaciones en las que necesite una funcionalidad adicional o un comportamiento específico, considere la posibilidad de crear clases de pares clave-valor personalizadas adaptadas a sus requisitos.

Biblioteca IronPDF

IronPDF de Iron Software Products es una excelente biblioteca para generar documentos PDF. Su facilidad de uso y eficacia son insuperables.

IronPDF puede instalarse desde el gestor de paquetes NuGet:

Install-Package IronPdf

O desde Visual Studio así:

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

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

Salida

Licencia de prueba para IronPDF

Consigue tuLicencia de prueba de IronPDF y colocar la licencia en el archivo appsettings.json.

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

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

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'"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 sencilla de la clase personalizada Pair junto con varios casos de uso que demuestran su versatilidad y utilidad en las tareas cotidianas de programación.

Tanto si está trabajando con coordenadas, devolviendo múltiples valores de un método, o almacenando asociaciones clave-valor, la clase Pair puede ser una valiosa adición a su conjunto de habilidades de programación.

Además, elFuncionalidad de la biblioteca IronPDF es una gran combinación de habilidades que los desarrolladores deben tener para generar documentos PDF sobre la marcha según se requiera en las aplicaciones.