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

Unindo a simplicidade da linha de comando e o .NET: usando Curl DotNet com IronPDF

Para desenvolvedores que precisam transitar entre scripts rápidos de ferramentas de linha de comando e código .NET robusto, a dificuldade geralmente reside em traduzir um comando cURL funcional em uma solicitação HTTP adequada em C#. Jacob Mellor preencheu essa lacuna com o CurlDotNet , uma biblioteca criada para trazer a familiaridade do cURL para o ecossistema .NET .

Ao combinar esta ferramenta com produtos da Iron Software, como o IronPDF ou o IronXL , você pode criar fluxos de trabalho robustos que buscam dados por meio de chamadas de API complexas e geram relatórios profissionais imediatamente. Neste artigo, veremos alguns exemplos de como essas ferramentas podem trabalhar juntas para levar seus projetos a um novo patamar.

O que é CurlDotNet?

CurlDotNet é uma implementação em C# .NET pura da ferramenta curl, padrão da indústria. Ao contrário de wrappers que dependem de bibliotecas nativas ou da libcurl, esta biblioteca oferece uma solução 100% gerenciada com suporte completo para Windows, Linux, macOS e outros sistemas operacionais. Isso garante o mesmo comportamento do cliente padrão, permitindo que você simplesmente cole uma cópia em bash de um comando da documentação da API diretamente no seu código.

Guia rápido e instalação

Para começar, basta executar o seguinte comando no diretório do seu projeto:

dotnet add package curldotnet

Isso instala o pacote CurlDotNet, dando acesso a receitas prontas para uso no tratamento de solicitações da web sem a sobrecarga da configuração do HttpClient.

Usando comandos Curl-Dot-Net

A biblioteca se destaca na análise de comandos com valores de string. Se você tiver uma string curl https funcional de uma página da API do GitHub ou de documentação interna, poderá executá-la diretamente.

using CurlDotNet;

// Simply copy-paste your shell command
var command = "curl -X GET https://api.github.com/users/jacob-mellor -H 'User-Agent: curl-dot-net'";
var result = await Curl.ExecuteAsync(command);
Console.WriteLine(result.Body);
using CurlDotNet;

// Simply copy-paste your shell command
var command = "curl -X GET https://api.github.com/users/jacob-mellor -H 'User-Agent: curl-dot-net'";
var result = await Curl.ExecuteAsync(command);
Console.WriteLine(result.Body);
Imports CurlDotNet

' Simply copy-paste your shell command
Dim command As String = "curl -X GET https://api.github.com/users/jacob-mellor -H 'User-Agent: curl-dot-net'"
Dim result = Await Curl.ExecuteAsync(command)
Console.WriteLine(result.Body)
$vbLabelText   $csharpLabel

Saída do código .NET Curl DotNet

Saída do nosso primeiro comando Curl DotNet

Para quem prefere uma abordagem estruturada, o construtor fluente oferece uma API clara para definir cabeçalhos, opções do curl e tokens de acesso.

var response = await Curl.GetAsync("https://api.github.com/users/ironsoftware")
    .WithHeader("Authorization", "Bearer YOUR_TOKEN")
    .WithHeader("X-API-Key", "12345")
    .ExecuteAsync();
var response = await Curl.GetAsync("https://api.github.com/users/ironsoftware")
    .WithHeader("Authorization", "Bearer YOUR_TOKEN")
    .WithHeader("X-API-Key", "12345")
    .ExecuteAsync();
Dim response = Await Curl.GetAsync("https://api.github.com/users/ironsoftware") _
    .WithHeader("Authorization", "Bearer YOUR_TOKEN") _
    .WithHeader("X-API-Key", "12345") _
    .ExecuteAsync()
$vbLabelText   $csharpLabel

Essa flexibilidade lida internamente com os mecanismos de handshake TLS, limitação de taxa e tratamento de erros, imitando o comportamento padrão do executável curl.

Integração com o Iron Software no .NET Framework

O verdadeiro poder é liberado quando você direciona a saída do CurlDotNet para as ferramentas do Iron Software . Como o CurlDotNet lida com a camada de transporte (buscando JSON, arquivos ou HTML), os produtos da Iron Software podem se concentrar no processamento desse conteúdo.

Cenário: Geração de relatórios em PDF a partir de dados de API

Imagine que você precisa baixar dados de usuários de um URL seguro e gerar um relatório em PDF. A API requer uma assinatura bash específica que é difícil de replicar com o HttpClient, mas fácil com um comando curl.

Passo 1: Obter dados com Curl-Dot-Net

// Define the curl command string with all necessary headers (here we use an example test website)
string curlCmd = "curl https://www.w3.org/TR/html4/ -H 'X-API-Key: secure_key'";

// Execute the request
var result = await Curl.ExecuteAsync(curlCmd);

// Extract the content (assumed to be HTML for this scenario)
string htmlContent = result.Body;
// Define the curl command string with all necessary headers (here we use an example test website)
string curlCmd = "curl https://www.w3.org/TR/html4/ -H 'X-API-Key: secure_key'";

// Execute the request
var result = await Curl.ExecuteAsync(curlCmd);

// Extract the content (assumed to be HTML for this scenario)
string htmlContent = result.Body;
Imports System.Threading.Tasks

' Define the curl command string with all necessary headers (here we use an example test website)
Dim curlCmd As String = "curl https://www.w3.org/TR/html4/ -H 'X-API-Key: secure_key'"

' Execute the request
Dim result = Await Curl.ExecuteAsync(curlCmd)

' Extract the content (assumed to be HTML for this scenario)
Dim htmlContent As String = result.Body
$vbLabelText   $csharpLabel

Passo 2: Gere o PDF com o IronPDF

IronPDF é uma biblioteca poderosa projetada para renderizar HTML, CSS, JavaScript e imagens em documentos PDF de alta fidelidade. Oferece suporte completo aos padrões modernos da web e inclui recursos como adicionar cabeçalhos, rodapés e definir opções específicas de renderização.

using IronPdf;

// Instantiate the renderer
var renderer = new ChromePdfRenderer();

// Convert the fetched HTML data to PDF
var pdf = renderer.RenderHtmlAsPdf(htmlContent);

// Save the file to the output path
pdf.SaveAs("output.pdf");
using IronPdf;

// Instantiate the renderer
var renderer = new ChromePdfRenderer();

// Convert the fetched HTML data to PDF
var pdf = renderer.RenderHtmlAsPdf(htmlContent);

// Save the file to the output path
pdf.SaveAs("output.pdf");
Imports IronPdf

' Instantiate the renderer
Dim renderer As New ChromePdfRenderer()

' Convert the fetched HTML data to PDF
Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)

' Save the file to the output path
pdf.SaveAs("output.pdf")
$vbLabelText   $csharpLabel

Saída

Site de teste convertido para PDF usando CurlDotNet e IronPDF

Cenário: Exportando JSON para o Excel

Se seu aplicativo consome um feed JSON, você pode buscá-lo usando os recursos de teste do CurlDotNet e exportá-lo usando o IronXL.

Passo 1: Obter dados JSON com Curl-Dot-Net

Utilizamos o Fluent Builder para gerar código .NET limpo e buscar o feed JSON:

string testUrl = "https://jsonplaceholder.typicode.com/users";

Console.WriteLine($"Executing HTTP request to fetch JSON from: {testUrl}");
// Replace the CurlDotNet fluent builder usage with the correct async method
var response = await Curl.GetAsync(testUrl); // Use Curl.GetAsync() for async HTTP GET

string jsonBody = response.Body;
string testUrl = "https://jsonplaceholder.typicode.com/users";

Console.WriteLine($"Executing HTTP request to fetch JSON from: {testUrl}");
// Replace the CurlDotNet fluent builder usage with the correct async method
var response = await Curl.GetAsync(testUrl); // Use Curl.GetAsync() for async HTTP GET

string jsonBody = response.Body;
Imports System

Dim testUrl As String = "https://jsonplaceholder.typicode.com/users"

Console.WriteLine($"Executing HTTP request to fetch JSON from: {testUrl}")
' Replace the CurlDotNet fluent builder usage with the correct async method
Dim response = Await Curl.GetAsync(testUrl) ' Use Curl.GetAsync() for async HTTP GET

Dim jsonBody As String = response.Body
$vbLabelText   $csharpLabel

Etapa 2: Carregar e exportar para o Excel usando o IronXL

IronXL é uma biblioteca .NET abrangente, projetada para lidar com todos os aspectos de leitura , gravação e manipulação de arquivos Excel (.xlsx, .xls, .csv). Fundamentalmente, ele faz isso sem a necessidade de instalar o Microsoft Office no servidor ou na máquina cliente, tornando-o ideal para ambientes Linux multiplataforma e de CI/CD. Os principais recursos incluem suporte completo para criação de gráficos, aplicação de fórmulas e estilização de células.

Com os dados JSON brutos agora em uma string, o IronXL pode ser usado para analisá-los e criar uma planilha.

var workbook = WorkBook.Create(ExcelFileFormat.XLSX);
 var sheet = workbook.CreateWorkSheet("User Data");

 // 1. Deserialize the JSON string to a list of UserRecord objects
 Console.WriteLine("Deserializing JSON data...");
 var salesRecords = JsonConvert.DeserializeObject<List<UserRecord>>(jsonBody);

 // 2. Insert the data into the sheet using IronXL's SetCellValue method
 Console.WriteLine("Inserting data into Excel using IronXL...");

 // Write headers
 sheet.SetCellValue(0, 0, "id");
 sheet.SetCellValue(0, 1, "name");
 sheet.SetCellValue(0, 2, "username");
 sheet.SetCellValue(0, 3, "email");

 // Write data rows
 for (int i = 0; i < salesRecords.Count; i++)
 {
     var record = salesRecords[i];
     sheet.SetCellValue(i + 1, 0, record.id);
     sheet.SetCellValue(i + 1, 1, record.name);
     sheet.SetCellValue(i + 1, 2, record.username);
     sheet.SetCellValue(i + 1, 3, record.email);
 }

 // Save the Excel file
 string filePath = "UserReport.xlsx";
 workbook.SaveAs(filePath);

 Console.WriteLine($"\n Success! Excel report saved to: {Path.GetFullPath(filePath)}");
var workbook = WorkBook.Create(ExcelFileFormat.XLSX);
 var sheet = workbook.CreateWorkSheet("User Data");

 // 1. Deserialize the JSON string to a list of UserRecord objects
 Console.WriteLine("Deserializing JSON data...");
 var salesRecords = JsonConvert.DeserializeObject<List<UserRecord>>(jsonBody);

 // 2. Insert the data into the sheet using IronXL's SetCellValue method
 Console.WriteLine("Inserting data into Excel using IronXL...");

 // Write headers
 sheet.SetCellValue(0, 0, "id");
 sheet.SetCellValue(0, 1, "name");
 sheet.SetCellValue(0, 2, "username");
 sheet.SetCellValue(0, 3, "email");

 // Write data rows
 for (int i = 0; i < salesRecords.Count; i++)
 {
     var record = salesRecords[i];
     sheet.SetCellValue(i + 1, 0, record.id);
     sheet.SetCellValue(i + 1, 1, record.name);
     sheet.SetCellValue(i + 1, 2, record.username);
     sheet.SetCellValue(i + 1, 3, record.email);
 }

 // Save the Excel file
 string filePath = "UserReport.xlsx";
 workbook.SaveAs(filePath);

 Console.WriteLine($"\n Success! Excel report saved to: {Path.GetFullPath(filePath)}");
Imports IronXL
Imports Newtonsoft.Json
Imports System.IO

Dim workbook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim sheet = workbook.CreateWorkSheet("User Data")

' 1. Deserialize the JSON string to a list of UserRecord objects
Console.WriteLine("Deserializing JSON data...")
Dim salesRecords = JsonConvert.DeserializeObject(Of List(Of UserRecord))(jsonBody)

' 2. Insert the data into the sheet using IronXL's SetCellValue method
Console.WriteLine("Inserting data into Excel using IronXL...")

' Write headers
sheet.SetCellValue(0, 0, "id")
sheet.SetCellValue(0, 1, "name")
sheet.SetCellValue(0, 2, "username")
sheet.SetCellValue(0, 3, "email")

' Write data rows
For i As Integer = 0 To salesRecords.Count - 1
    Dim record = salesRecords(i)
    sheet.SetCellValue(i + 1, 0, record.id)
    sheet.SetCellValue(i + 1, 1, record.name)
    sheet.SetCellValue(i + 1, 2, record.username)
    sheet.SetCellValue(i + 1, 3, record.email)
Next

' Save the Excel file
Dim filePath As String = "UserReport.xlsx"
workbook.SaveAs(filePath)

Console.WriteLine(vbCrLf & " Success! Excel report saved to: " & Path.GetFullPath(filePath))
$vbLabelText   $csharpLabel

Arquivo Excel de saída

Arquivo Excel criado com CurlDotNet e IronExcel

Por que essa combinação?

  1. Consistência entre plataformas: Os produtos CurlDotNet e IronSoftware são compatíveis com Windows, Linux e macOS. Isso é fundamental para pipelines de CI/CD executados em ambientes de tempo de execução como o Microsoft Azure ou o AWS Lambda.

  2. Geração de código: Os desenvolvedores geralmente recebem trechos de código gerados em formato bash ou shell. O curl-dot-net permite que você use esses trechos de código diretamente, enquanto o Iron Software cuida da parte mais complexa da manipulação de documentos.

  3. Sem dependências nativas: Como o CurlDotNet é uma implementação em C# puro, você evita problemas comuns associados à vinculação de bibliotecas C++ externas ou binários libcurl em diferentes versões do sistema operacional.

Conclusão

Jacob Mellor forneceu uma ferramenta vital para a comunidade DotNet. Ao permitir que os desenvolvedores usem opções familiares do curl em aplicativos .NET Framework e Core, o CurlDotNet simplifica o processo de requisição HTTP. Ao ser combinado com o Iron Software, você pode criar um fluxo de trabalho perfeito: busque dados com a precisão do curl e processe-os com o poder do IronPDF ou do IronXL.

Caso encontre algum problema, não deixe de reportá-lo na página do GitHub para ajudar a melhorar o suporte a todos os usuários.

Perguntas frequentes

O que é CurlDotNet?

CurlDotNet é uma biblioteca criada por Jacob Mellor para trazer a funcionalidade do cURL para o ecossistema .NET, permitindo que os desenvolvedores traduzam facilmente comandos cURL em código .NET.

Como o CurlDotNet ajuda os desenvolvedores?

O CurlDotNet ajuda os desenvolvedores simplificando o processo de tradução de operações da linha de comando cURL em solicitações HTTP em C#, facilitando a integração de scripts de ferramentas de linha de comando em aplicativos .NET robustos.

Que problema o CurlDotNet resolve?

CurlDotNet resolve o problema de atrito que os desenvolvedores enfrentam ao tentar converter comandos cURL funcionais em requisições HTTP adequadas em C#. Ele oferece uma abordagem familiar para aqueles acostumados com a simplicidade do cURL.

É possível usar o CurlDotNet com o IronPDF?

Sim, o CurlDotNet pode ser usado em conjunto com o IronPDF para facilitar a realização de requisições HTTP como parte dos fluxos de trabalho de geração de PDFs em aplicações .NET.

O CurlDotNet é adequado para iniciantes?

Sim, o CurlDotNet é adequado para iniciantes, pois oferece uma interface familiar no estilo de linha de comando, o que facilita o aprendizado para quem é novo no .NET e em requisições HTTP.

Quais são os benefícios de usar o CurlDotNet com o IronPDF?

A utilização do CurlDotNet com o IronPDF permite aos desenvolvedores simplificar as requisições HTTP durante a geração de PDFs, melhorando a eficiência e aproveitando os pontos fortes de ambas as ferramentas.

Onde posso aprender mais sobre CurlDotNet?

Você pode aprender mais sobre o CurlDotNet visitando o artigo de Jacob Mellor no Medium, que fornece informações detalhadas sobre como a biblioteca preenche a lacuna entre os comandos cURL e o código .NET.

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