Classe Pair em C# (Como funciona para desenvolvedores)
Um par é uma estrutura de dados simples que armazena dois valores relacionados. Isso proporciona uma maneira conveniente de agrupar duas partes distintas de dados. Os pares são comumente usados quando um método precisa retornar dois valores ou quando se trabalha com associações de chave-valor.
Em C#, os desenvolvedores frequentemente recorrem ao uso de tuplas (Tuple<T1, T2>) para emparelhar valores. No entanto, as tuplas são imutáveis e seus elementos são acessados por meio de propriedades como Item1 e Item2, o que pode resultar em um código menos legível quando usadas extensivamente. É aí que uma classe Pair personalizada se torna útil.
Se você precisa de uma estrutura para armazenar dois objetos relacionados e o ocultamento de dados não é uma prioridade, você pode utilizar a classe Pair em seu código. A classe Pair não encapsula suas referências de objeto. Em vez disso, expõe-nos diretamente a todos os códigos que os chamam como campos de classe públicos.
Essa escolha de design permite acesso direto aos objetos contidos, sem a sobrecarga do encapsulamento. Além disso, ao final do artigo, exploraremos como o IronPDF para geração de PDFs, da Visão Geral do Iron Software, pode ser usado para gerar um documento PDF.
Tuplas
O C# 7.0 introduziu melhorias na sintaxe de tuplas, tornando ainda mais fácil trabalhar com elas. Eis como você pode 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}");
' 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}")
Benefícios das Tuplas
Sintaxe concisa
As tuplas permitem expressar estruturas de dados complexas usando uma sintaxe concisa, sem a necessidade de definir classes ou structs personalizados.
Leve
As tuplas são estruturas de dados leves, o que as torna adequadas para cenários em que você precisa de armazenamento temporário ou intermediário de dados.
Nomeação implícita
Com a sintaxe de tupla, você pode nomear implicitamente os elementos da tupla, melhorando a legibilidade do código e reduzindo a necessidade de comentários.
Retornando múltiplos valores de 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}");
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}")
Simplificando as assinaturas 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}");
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}")
Agrupamento de dados 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)
Limitações e Considerações
Embora as tuplas do C# 7.0 ofereçam benefícios significativos, existem algumas limitações e considerações a serem levadas em conta:
- As tuplas são limitadas em termos de expressividade em comparação com classes ou structs personalizados.
- Os elementos da tupla são acessados usando Item1, Item2, etc. quando nomes explícitos não são fornecidos, o que pode reduzir a legibilidade do código.
Classe personalizada em pares
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;
}
}
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 Class
Nessa classe, os tipos são definidos no momento do uso, e as duas propriedades são expostas como propriedades públicas.
Usando a classe Pair
Agora, vamos explorar alguns casos de uso comuns em que a classe Pair pode ser benéfica:
1. Armazenando 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}");
' 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}")
2. Retornando múltiplos valores de um 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}");
' 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}")
3. Armazenando pares de chave-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}");
' Storing a key-value pair
Dim keyValue As New Pair(Of String, Integer)("Age", 30)
Console.WriteLine($"Key: {keyValue.First}, Value: {keyValue.Second}")
Pares de chave-valor
Os pares chave-valor oferecem uma maneira simples e eficiente de associar dados. Em C#, a principal ferramenta para trabalhar com pares chave-valor é a classe Dictionary<TKey, TValue>, um tipo de coleção versátil e poderoso.
Entendendo pares de chave-valor
Um par chave-valor é uma estrutura de dados que associa uma chave única a um valor. Essa associação permite a recuperação e manipulação eficientes de dados com base em seu identificador único. Em C#, pares de chave-valor são comumente usados para tarefas como armazenamento em cache, gerenciamento de configuração e armazenamento de dados.
Dictionary<TKey, TValue> in C
A classe Dictionary<TKey, TValue> em C# é uma coleção genérica que armazena pares de chave-valor. Ele oferece buscas rápidas baseadas em chaves e é amplamente utilizado para gerenciar dados associativos.
Criando e preenchendo um dicionário
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 }
};
Dim ages As New Dictionary(Of String, Integer) From {
{"Alice", 30},
{"Bob", 35},
{"Charlie", 25}
}
Acessando valores por chave
// 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"]}");
' Directly access a value by its key
Console.WriteLine($"Alice's age: {ages("Alice")}")
Iterando sobre pares chave-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}");
}
' Iterate over all key-value pairs in the dictionary
For Each pair In ages
Console.WriteLine($"Name: {pair.Key}, Age: {pair.Value}")
Next pair
Cenários Avançados
Como lidar com chaves 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
Removendo entradas
// Remove an entry given its key
ages.Remove("Charlie");
// Remove an entry given its key
ages.Remove("Charlie");
' Remove an entry given its key
ages.Remove("Charlie")
Inicialização do dicionário
// 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" }
};
' Initialize a dictionary with color codes
Dim colors = New Dictionary(Of String, String) From {
{"red", "#FF0000"},
{"green", "#00FF00"},
{"blue", "#0000FF"}
}
Além do dicionário: alternativas e considerações
Embora o Dictionary<TKey, TValue> seja uma ferramenta poderosa, abordagens e considerações alternativas dependem dos requisitos específicos da sua aplicação:
ConcurrentDictionary<TKey, TValue>: Se o seu aplicativo exigir acesso thread-safe ao dicionário a partir de múltiplas threads, considere usarConcurrentDictionary<TKey, TValue>.ImmutableDictionary<TKey, TValue>: Para cenários onde a imutabilidade é desejada,ImmutableDictionary<TKey, TValue>do namespaceSystem.Collections.Immutablefornece coleções imutáveis de chave-valor.- Classes personalizadas de pares chave-valor: Em situações onde você precisa de funcionalidades adicionais ou comportamentos específicos, considere criar classes personalizadas de pares chave-valor adaptadas às suas necessidades.
Biblioteca IronPDF
IronPDF, da Iron Software Products, é uma excelente biblioteca para gerar documentos PDF. Sua facilidade de uso e eficiência são incomparáveis.
O IronPDF se destaca na conversão de HTML para PDF , garantindo a preservação precisa dos layouts e estilos originais. É perfeito para criar PDFs a partir de conteúdo da web, como relatórios, faturas e documentação. Com suporte para arquivos HTML, URLs e strings HTML brutas, o IronPDF produz facilmente documentos PDF de alta qualidade.
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
O IronPDF pode ser instalado através do gerenciador de pacotes NuGet :
Install-Package IronPdf
Ou, no Visual Studio, assim:

Para gerar um documento com um exemplo de tupla, podemos usar o seguinte 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);
}
}
}
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
Saída

Licença de avaliação do IronPDF
Obtenha sua licença de avaliação do IronPDF e coloque a licença no appsettings.json.
{
"IronPdf.LicenseKey": "<Your Key>"
}
Conclusão
Neste artigo, exploramos o conceito de pares e a importância de ter uma classe Pair em C#. Fornecemos uma implementação simples da classe personalizada Pair, juntamente com vários casos de uso que demonstram sua versatilidade e utilidade em tarefas de programação do dia a dia.
Seja trabalhando com coordenadas, retornando múltiplos valores de um método ou armazenando associações de chave-valor, a classe Pair pode ser uma adição valiosa ao seu conjunto de habilidades de programação.
Além disso, a funcionalidade da biblioteca IronPDF é uma excelente combinação de habilidades que os desenvolvedores precisam ter para gerar documentos PDF dinamicamente, conforme necessário em seus aplicativos.
Perguntas frequentes
O que é uma classe Pair em C#?
A classe Pair em C# é uma estrutura de dados simples projetada para armazenar dois valores relacionados. Ela permite acesso direto às suas propriedades como campos públicos, tornando-se uma alternativa conveniente às tuplas quando o encapsulamento não é uma prioridade.
Em C#, qual a diferença entre a classe Pair e a classe Tuple?
A classe Pair difere de uma Tuple por expor suas referências de objeto diretamente por meio de campos públicos, aumentando a legibilidade e a flexibilidade. As tuplas, por outro lado, são imutáveis e acessam seus elementos por meio de propriedades como Item1 e Item2 .
Quais são as vantagens de usar a classe Pair em vez de tuplas?
As vantagens de usar a classe Pair em vez de tuplas incluem uma melhor legibilidade do código, graças ao uso de nomes de propriedades descritivos em vez de Item1 e Item2 , e a capacidade de modificar os valores, já que os Pairs são mutáveis.
Posso usar a classe Pair para armazenar pares de chave-valor?
Sim, a classe Pair é particularmente útil para armazenar pares de chave-valor de uma forma mais legível em comparação com tuplas, devido ao seu acesso direto aos valores através de campos públicos.
Quais são alguns cenários comuns para usar a classe Pair em C#?
Os cenários comuns para o uso da classe Pair incluem armazenar coordenadas, retornar múltiplos valores de um método e gerenciar associações de pares chave-valor em um formato legível.
Por que um desenvolvedor escolheria usar a biblioteca IronPDF?
Um desenvolvedor pode optar por usar a biblioteca IronPDF para gerar PDFs a partir de conteúdo HTML. Isso garante que o layout e o estilo originais sejam preservados, simplificando a criação de documentos profissionais, como relatórios e faturas.
Como posso gerar um PDF a partir de um arquivo HTML em C#?
É possível gerar um PDF a partir de um arquivo HTML em C# usando a biblioteca IronPDF. Ela fornece métodos como RenderHtmlAsPdf para converter strings e arquivos HTML em documentos PDF de alta qualidade.
Qual a vantagem de usar uma biblioteca para geração de PDFs?
Utilizar uma biblioteca como o IronPDF para geração de PDFs oferece processos simplificados para a criação de documentos PDF de alta qualidade, garantindo a preservação precisa do layout e do estilo a partir de diversas fontes de conteúdo.
Que funções desempenham a classe Pair e a biblioteca IronPDF no conjunto de ferramentas de um desenvolvedor?
A classe Pair e a biblioteca IronPDF aprimoram o conjunto de ferramentas de um desenvolvedor, fornecendo gerenciamento eficiente de estruturas de dados com Pairs e recursos confiáveis de geração de documentos com IronPDF, tornando-as valiosas para lidar com fluxos de trabalho complexos de dados e documentos.




