Bridging CLI Simplicity & .NET : Using Curl DotNet with IronPDF for .NET (en anglais)
Pour les développeurs qui naviguent entre les scripts d'outils de ligne de commande rapides et le code .NET robuste, la friction réside souvent dans la traduction d'une commande cURL fonctionnelle en une requête HTTP correcte au sein de C#. Jacob Mellor a comblé cette lacune avec CurlDotNet, une bibliothèque créée pour apporter la familiarité de cURL à l'écosystème .NET.
En combinant cet outil avec des produits Iron Software tels que IronPDF ou IronXL, vous pouvez créer de puissants pipelines qui récupèrent des données via des appels d'API complexes et génèrent immédiatement des rapports professionnels. Dans cet article, nous examinerons quelques exemples où ces outils peuvent fonctionner ensemble pour faire passer vos projets au niveau supérieur.
Qu'est-ce que CurlDotNet ?
CurlDotNet est une implémentation purement C# .NET de l'outil curl standard de l'industrie. Contrairement aux wrappers qui s'appuient sur des dépendances natives ou sur libcurl, cette bibliothèque offre une solution gérée à 100 % avec une prise en charge complète pour Windows, Linux, macOS, etc. Elle garantit le même comportement que le client standard, ce qui vous permet de simplement coller une copie bash d'une commande de la documentation de l'API directement dans votre code.
Démarrage rapide et installation
Pour commencer, il suffit d'exécuter la commande suivante dans le répertoire de votre projet :
dotnet add package curldotnet
Ceci installe le paquet CurlDotNet, vous donnant accès à des recettes prêtes à l'emploi pour traiter les requêtes web sans la surcharge de la configuration du HttpClient.
Utilisation des commandes Curl-Dot-Net Curl
La bibliothèque excelle dans l'analyse des commandes de valeur de chaîne. Si vous disposez d'une chaîne curl https fonctionnelle provenant d'une page API GitHub ou d'une documentation interne, vous pouvez l'exécuter directement.
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)
Sortie de curl .NET Code .NET

Pour ceux qui préfèrent une approche structurée, le constructeur fluent fournit une API propre pour définir les en-têtes, les options curl et les jetons d'accès.
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()
Cette flexibilité gère les mécanismes de la poignée de main TLS, la limitation du débit et la gestion des erreurs en interne, en imitant le comportement par défaut de l'exécutable curl.
Intégration avec Iron Software dans le .NET Framework
La véritable puissance se dévoile lorsque vous acheminez la sortie de CurlDotNet dans les outils d'Iron Software. Étant donné que CurlDotNet gère la couche de transport (récupération de JSON, de fichiers ou de HTML), les produits Iron Software peuvent se concentrer sur le traitement de ce contenu.
Scénario : Génération de rapports PDF à partir de données API
Imaginez que vous deviez télécharger des données utilisateur à partir d'une URL sécurisée et générer un rapport PDF. L'API nécessite une signature bash spécifique qui est difficile à reproduire avec HttpClient mais facile avec une commande curl.
Étape 1 : Récupérer des données avec 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
Étape 2 : Générer un fichier PDF avec IronPDF
IronPDF est une puissante bibliothèque conçue pour rendre HTML, CSS, JavaScript, et images en documents PDF de haute fidélité. Elle offre une prise en charge complète des normes web modernes et inclut des fonctionnalités telles que l'ajout d'en-têtes, de pieds de page et la définition d'options de rendu spécifiques.
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")
Sortie

Scénario : Exportation de JSON vers Excel
Si votre application consomme un flux JSON, vous pouvez le récupérer à l'aide des capacités de test de CurlDotNet et l'exporter à l'aide d'IronXL.
Étape 1 : Récupérer des données JSON avec Curl-Dot-Net
Nous utilisons le fluent builder pour un code .NET propre afin de récupérer le flux 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
Étape 2 : Chargement et exportation vers Excel à l'aide d'IronXL
IronXL est une bibliothèque .NET complète conçue pour gérer tous les aspects de la lecture, l'écriture et la manipulation des formats de fichiers Excel (.xlsx, .xls, .csv). Il est important de noter que Microsoft Office n'a pas besoin d'être installé sur le serveur ou la machine cliente, ce qui en fait un outil idéal pour les environnements Linux et CI CD multiplateformes. Parmi les principales fonctionnalités, citons la prise en charge complète de la création de graphiques, l'application de formules et le stylisme des cellules.
Les données JSON brutes étant désormais sous forme de chaîne, IronXL peut être utilisé pour les analyser et construire une feuille de calcul.
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))
Fichier Excel de sortie

Pourquoi cette combinaison ?
-
Cohérence multiplateforme : Les produits CurlDotNet et IronSoftware prennent tous deux en charge Windows, Linux et macOS. Cela est essentiel pour les pipelines CI CD fonctionnant sur des environnements d'exécution tels que Microsoft Azure ou AWS Lambda.
-
Génération de code : Les développeurs reçoivent souvent des extraits de code générés au format bash ou shell. curl.net vous permet d'utiliser directement ces extraits de code, tandis Iron Software se charge du gros du travail de manipulation des documents.
- Aucune dépendance native : comme CurlDotNet est une implémentation C# pure, vous évitez les problèmes courants liés à la liaison de bibliothèques C++ externes ou de binaires libcurl sur différentes versions de systèmes d'exploitation.
Conclusion
Jacob Mellor a fourni un outil essentiel à la communauté DotNet. En permettant aux développeurs d'utiliser des options curl familières au sein des applications .NET Framework et Core, CurlDotNet simplifie le processus de requête http. Associé à Iron Software, vous pouvez créer un flux de travail transparent : récupérez des données avec la précision de curl et traitez-les avec la puissance d'IronPDF ou d'IronXL.
Si vous rencontrez des problèmes, n'oubliez pas de les signaler sur la page GitHub afin d'améliorer l'assistance pour tous les utilisateurs.
Questions Fréquemment Posées
Qu'est-ce que CurlDotNet ?
CurlDotNet est une bibliothèque créée par Jacob Mellor pour apporter la fonctionnalité de cURL à l'écosystème .NET, permettant aux développeurs de traduire facilement les commandes cURL en code .NET.
Comment CurlDotNet aide-t-il les développeurs ?
CurlDotNet aide les développeurs en simplifiant le processus de traduction des opérations de ligne de commande cURL en requêtes HTTP au sein de C#, ce qui facilite l'intégration des scripts d'outils de ligne de commande dans des applications .NET robustes.
Quel problème CurlDotNet résout-il ?
CurlDotNet résout le problème de friction auquel les développeurs sont confrontés lorsqu'ils tentent de convertir des commandes cURL fonctionnelles en requêtes HTTP correctes en C#. Il offre une approche familière à ceux qui sont habitués à la simplicité de cURL.
CurlDotNet peut-il être utilisé avec IronPDF ?
Oui, CurlDotNet peut être utilisé parallèlement à IronPDF pour améliorer la facilité d'effectuer des requêtes HTTP dans le cadre des flux de travail de génération de PDF au sein des applications .NET.
CurlDotNet est-il adapté aux débutants ?
Oui, CurlDotNet convient aux débutants, car il offre une interface familière de type ligne de commande qui facilite l'apprentissage pour ceux qui ne connaissent pas .NET et les requêtes HTTP.
Quels sont les avantages de l'utilisation de CurlDotNet avec IronPDF ?
L'utilisation de CurlDotNet avec IronPDF permet aux développeurs de rationaliser les requêtes HTTP tout en générant des PDF, en améliorant l'efficacité et en tirant parti des atouts des deux outils.
Où puis-je en savoir plus sur CurlDotNet ?
Pour en savoir plus sur CurlDotNet, consultez l'article de Jacob Mellor sur Medium, qui explique en détail comment la bibliothèque comble le fossé entre les commandes cURL et le code .NET.




