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 costumam recorrer 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.
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
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}")As tuplas permitem expressar estruturas de dados complexas usando uma sintaxe concisa, sem a necessidade de definir classes ou structs personalizados.
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.
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.
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}")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}")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)Embora as tuplas do C# 7.0 ofereçam benefícios significativos, existem algumas limitações e considerações a serem levadas em conta:
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 ClassNessa classe, os tipos são definidos no momento do uso, e as duas propriedades são expostas como propriedades públicas.
Agora, vamos explorar alguns casos de uso comuns em que a classe Pair pode ser benéfica:
// 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}")// 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}")// 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}")Os pares chave-valor oferecem uma maneira simples e eficiente de associar dados. Em C#, a ferramenta principal para trabalhar com pares de chave-valor é a classe Dictionary<TKey, TValue>, um tipo de coleção versátil e poderoso.
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.
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}
}// 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")}")// 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 pairif (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// Remove an entry given its key
ages.Remove("Charlie");' Remove an entry given its key
ages.Remove("Charlie")// 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"}
}Embora Dictionary<TKey, TValue> seja uma ferramenta poderosa, abordagens alternativas e considerações dependem dos requisitos específicos do seu aplicativo:
ConcurrentDictionary<TKey, TValue>: Se seu aplicativo requer acesso seguro por thread ao dicionário de múltiplos threads, considere usar ConcurrentDictionary<TKey, TValue>.ImmutableDictionary<TKey, TValue>: Para cenários onde a imutabilidade é desejada, ImmutableDictionary<TKey, TValue> do namespace System.Collections.Immutable fornece coleções imutáveis de chave-valor.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");
}
}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 ClassO IronPDF pode ser instalado através do gerenciador de pacotes NuGet :
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);
}
}
}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
Adquira sua Licença de Avaliação do IronPDF e coloque a licença no appsettings.json.
{
"IronPdf.LicenseKey": "<Your Key>"
}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 demonstrando 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.
Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais bem estruturados e visualmente atraentes.
IronPDF faz parte do IRON SUITE.
10 produtos de API .NET para seus documentos de escritório
Quando você precisa que seu PDF tenha a aparência de HTML, rapidamente.
