Brückenschlag zwischen einfacher CLI und .NET: Curl DotNet mit IronPDF
Für Entwickler, die den Spagat zwischen schnellen Kommandozeilenskripten und robustem .NET-Code meistern müssen, besteht die Schwierigkeit oft darin, einen funktionierenden cURL-Befehl in eine korrekte HTTP-Anfrage in C# zu übersetzen. Jacob Mellor hat diese Lücke mit CurlDotNet überbrückt, einer Bibliothek, die die Vertrautheit von cURL in das .NET-Ökosystem bringt.
Durch die Kombination dieses Tools mit Iron Software Produkten wie IronPDF oder IronXL können Sie leistungsstarke Pipelines aufbauen, die Daten über komplexe API-Aufrufe abrufen und sofort professionelle Berichte erstellen. In diesem Artikel sehen wir uns einige Beispiele an, bei denen diese Tools zusammenarbeiten können, um Ihre Projekte auf die nächste Stufe zu heben.
Was ist CurlDotNet?
CurlDotNet ist eine reine C#-.NET-Implementierung des branchenüblichen Curl-Tools. Im Gegensatz zu Wrappern, die auf nativen Abhängigkeiten oder libcurl beruhen, bietet diese Bibliothek eine zu 100 % verwaltete Lösung mit voller Unterstützung für Windows, Linux, macOS und mehr. Sie gewährleistet das gleiche Verhalten wie der Standard-Client, so dass Sie einfach eine Bash-Kopie eines Befehls aus den API-Dokumenten direkt in Ihren Code einfügen können.
Schnellstart und Installation
Um loszulegen, führen Sie einfach den folgenden Befehl in Ihrem Projektverzeichnis aus:
dotnet add package curldotnet
Dadurch wird das Paket CurlDotNet installiert, das Ihnen Zugriff auf fertige Rezepte für die Bearbeitung von Webanfragen ohne den Overhead der HttpClient-Konfiguration bietet.
Verwendung von Curl-Dot-Net Curl-Befehlen
Die Bibliothek zeichnet sich durch das Parsen von String-Wert-Befehlen aus. Wenn Sie einen funktionierenden curl https-String von einer GitHub-API-Seite oder internen Dokumenten haben, können Sie ihn direkt ausführen.
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)
.NET Code Curl DotNet Ausgabe

Für diejenigen, die einen strukturierten Ansatz bevorzugen, bietet der Fluent Builder eine saubere API zum Festlegen von Headern, Curl-Optionen und Zugriffstokens.
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()
Diese Flexibilität behandelt TLS-Handshake-Mechanismen, Ratenbegrenzung und Fehlerbehandlung intern und ahmt das Standardverhalten der ausführbaren Datei curl nach.
Integration mit Iron Software im .NET Framework
Die wirkliche Leistung wird freigeschaltet, wenn Sie die Ausgabe von CurlDotNet in Iron Software-Tools einspeisen. Da CurlDotNet die Transportschicht übernimmt (Abrufen von JSON, Dateien oder HTML), können sich die Produkte von Iron Software auf die Verarbeitung dieser Inhalte konzentrieren.
Szenario: Generierung von PDF-Berichten aus API-Daten
Stellen Sie sich vor, Sie müssen Benutzerdaten von einer sicheren URL herunterladen und einen PDF-Bericht erstellen. Die API erfordert eine bestimmte Bash-Signatur, die mit HttpClient nur schwer, mit einem curl-Befehl aber leicht zu replizieren ist.
Schritt 1: Abrufen von Daten mit 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
Schritt 2: Erzeugen von PDF mit IronPDF
IronPDF ist eine leistungsstarke Bibliothek, die HTML, CSS, JavaScript und Bilder in originalgetreue PDF-Dokumente umwandelt. Sie bietet volle Unterstützung für moderne Webstandards und umfasst Funktionen wie das Hinzufügen von Kopf- und Fußzeilen und die Einstellung bestimmter Rendering-Optionen.
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")
Ausgabe

Szenario: Exportieren von JSON nach Excel
Wenn Ihre Anwendung einen JSON-Feed verbraucht, können Sie ihn mit den Testfunktionen von CurlDotNet abrufen und mit IronXL exportieren.
Schritt 1: Abrufen von JSON-Daten mit Curl-Dot-Net
Wir verwenden den Fluent Builder für sauberen .NET-Code, um den JSON-Feed abzurufen:
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
Schritt 2: Laden und Exportieren nach Excel mit IronXL
IronXL ist eine umfassende .NET-Bibliothek, die alle Aspekte des Lesens, Schreibens und der Bearbeitung von Excel-Dateiformaten (.xlsx, .xls, .csv) behandelt. Entscheidend ist, dass dazu kein Microsoft Office auf dem Server oder Client-Rechner installiert sein muss, was es ideal für plattformübergreifende Linux- und CI-CD-Umgebungen macht. Zu den wichtigsten Funktionen gehören die vollständige Unterstützung für die Erstellung von Diagrammen, Anwendung von Formeln und die Gestaltung von Zellen.
Da die JSON-Rohdaten nun in einer Zeichenkette vorliegen, kann IronXL verwendet werden, um sie zu analysieren und eine Kalkulationstabelle zu erstellen.
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))
Ausgabedatei

Warum diese Kombination?
-
Plattformübergreifende Konsistenz: Sowohl CurlDotNet- als auch IronSoftware- Produkte unterstützen Windows, Linux und macOS. Dies ist entscheidend für CI-CD-Pipelines, die auf Laufzeitumgebungen wie Microsoft Azure oder AWS Lambda laufen.
-
Codegenerierung: Entwickler erhalten häufig Code-Generierungs-Snippets im Bash- oder Shell-Format. curl-dot-net ermöglicht die direkte Verwendung dieser Code-Snippets, während Iron Software die aufwendige Dokumentenbearbeitung übernimmt.
- Keine nativen Abhängigkeiten: Da CurlDotNet eine reine C#-Implementierung ist, vermeiden Sie die üblicherweise auftretenden Probleme beim Verknüpfen externer C++-Bibliotheken oder libcurl-Binärdateien auf verschiedenen Betriebssystemversionen.
Abschluss
Jacob Mellor hat ein wichtiges Werkzeug für die DotNet-Gemeinschaft zur Verfügung gestellt. CurlDotNet ermöglicht es Entwicklern, vertraute Curl-Optionen innerhalb von .NET Framework- und Core-Anwendungen zu verwenden und vereinfacht damit den http-Anfrageprozess. In Kombination mit Iron Software können Sie einen nahtlosen Arbeitsablauf schaffen: Daten mit der Präzision von Curl abrufen und mit der Leistung von IronPDF oder IronXL verarbeiten.
Wenn Sie auf Probleme stoßen, melden Sie bitte Fehler auf der GitHub-Seite, um den Support für alle Benutzer zu verbessern.
Häufig gestellte Fragen
Was ist CurlDotNet?
CurlDotNet ist eine Bibliothek, die von Jacob Mellor entwickelt wurde, um die Funktionalität von cURL in das .NET-Ökosystem zu bringen und Entwicklern die einfache Übersetzung von cURL-Befehlen in .NET-Code zu ermöglichen.
Wie kann CurlDotNet Entwicklern helfen?
CurlDotNet hilft Entwicklern durch die Vereinfachung des Prozesses der Übersetzung von cURL-Befehlszeilenoperationen in HTTP-Anfragen in C#, wodurch es einfacher wird, Befehlszeilenskripte in robuste .NET-Anwendungen zu integrieren.
Welches Problem wird mit CurlDotNet gelöst?
CurlDotNet löst das Problem der Reibung, mit dem Entwickler konfrontiert sind, wenn sie versuchen, funktionierende cURL-Befehle in korrekte HTTP-Anfragen in C# zu konvertieren. Es bietet einen vertrauten Ansatz für diejenigen, die an die Einfachheit von cURL gewöhnt sind.
Kann CurlDotNet mit IronPDF verwendet werden?
Ja, CurlDotNet kann zusammen mit IronPDF verwendet werden, um die Einfachheit von HTTP-Anfragen als Teil von PDF-Generierungs-Workflows innerhalb von .NET-Anwendungen zu verbessern.
Ist CurlDotNet für Anfänger geeignet?
Ja, CurlDotNet ist für Anfänger geeignet, da es eine vertraute Benutzeroberfläche im Befehlszeilenstil bietet, die den Einstieg in .NET und HTTP-Anfragen erleichtert.
Was sind die Vorteile der Verwendung von CurlDotNet mit IronPDF?
Die Verwendung von CurlDotNet mit IronPDF ermöglicht es Entwicklern, HTTP-Anfragen bei der PDF-Erzeugung zu rationalisieren, die Effizienz zu verbessern und die Stärken beider Tools zu nutzen.
Wo kann ich mehr über CurlDotNet erfahren?
Sie können mehr über CurlDotNet erfahren, indem Sie den Artikel von Jacob Mellor auf Medium besuchen, der detaillierte Einblicke darüber gibt, wie die Bibliothek die Lücke zwischen cURL-Befehlen und .NET-Code überbrückt.




