Ir para o conteúdo do rodapé
AJUDA DO .NET

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 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.
  • 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
$vbLabelText   $csharpLabel

O IronPDF pode ser instalado através do gerenciador de pacotes NuGet :

Install-Package IronPdf

Ou, no Visual Studio, assim:

Classe C# Pair (Como funciona para desenvolvedores): Figura 1 - Instalando o IronPDF com o gerenciador de pacotes NuGet

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

Saída

Classe Pair em C# (Como funciona para desenvolvedores): Figura 2

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.

Curtis Chau
Redator Técnico

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

Leia mais

Equipe de suporte de ferro

Estamos online 24 horas por dia, 5 dias por semana.
Bater papo
E-mail
Liga para mim