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)
Saída do código .NET 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()
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
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")
Saída

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
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))
Arquivo Excel de saída

Por que essa combinação?
-
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.
-
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.
- 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.




