Łączenie prostoty CLI i .NET: Używanie Curl DotNet z IronPDF
Dla programistów poruszających się między szybkimi skryptami narzędzi wiersza poleceń a solidnym kodem .NET, trudność często polega na przekształceniu działającego polecenia cURL w prawidłowe żądanie HTTP w języku C#. Jacob Mellor wypełnił tę lukę dzięki CurlDotNet, bibliotece stworzonej w celu przeniesienia znanego środowiska cURL do ekosystemu .NET.
Łącząc to narzędzie z produktami Iron Software, takimi jak IronPDF lub IronXL, można tworzyć potężne potoki, które pobierają dane za pomocą złożonych wywołań API i natychmiast generują profesjonalne raporty. W tym artykule przyjrzymy się kilku przykładom, w których narzędzia te mogą współpracować, aby przenieść Twoje projekty na wyższy poziom.
Czym jest CurlDotNet?
CurlDotNet to implementacja standardowego narzędzia curl w języku C# .NET. W przeciwieństwie do opakowań opartych na natywnych zależnościach lub libcurl, ta biblioteka oferuje w 100% zarządzane rozwiązanie z pełną obsługą systemów Windows, Linux, macOS i innych. Zapewnia to takie samo działanie jak standardowy klient, umożliwiając po prostu wklejenie kopii polecenia bash z dokumentacji API bezpośrednio do kodu.
Szybki start i instalacja
Aby rozpocząć, wystarczy uruchomić następujące polecenie w katalogu projektu:
dotnet add package curldotnet
Spowoduje to zainstalowanie pakietu CurlDotNet, dając Ci dostęp do gotowych do użycia receptur na obsługę żądań internetowych bez obciążenia związanego z konfiguracją HttpClient.
Korzystanie z poleceń Curl-Dot-Net Curl
Biblioteka doskonale radzi sobie z analizowaniem poleceń zawierających wartości łańcuchowe. Jeśli masz działający ciąg curl https ze strony API GitHub lub dokumentacji wewnętrznej, możesz go bezpośrednio wykonać.
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)
Kod .NET Curl Wynik DotNet

Dla tych, którzy preferują podejście strukturalne, Fluent Builder zapewnia przejrzysty interfejs API do ustawiania nagłówków, opcji curl i tokenów dostępu.
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()
Ta elastyczność pozwala na wewnętrzne obsługiwanie mechanizmów uzgadniania TLS, ograniczania szybkości i obsługi błędów, naśladując domyślne zachowanie pliku wykonywalnego curl.
Integracja z oprogramowaniem Iron Software w środowisku .NET Framework
Prawdziwa moc ujawnia się, gdy przekierujesz dane wyjściowe CurlDotNet do narzędzi Iron Software. Ponieważ CurlDotNet obsługuje warstwę transportową (pobieranie JSON, plików lub HTML), produkty Iron Software mogą skupić się na przetwarzaniu tych treści.
Scenariusz: Generowanie raportów PDF na podstawie danych z API
Wyobraź sobie, że musisz pobrać dane użytkownika z bezpiecznego adresu URL i wygenerować raport w formacie PDF. API wymaga określonego podpisu bash, który jest trudny do odtworzenia za pomocą HttpClient, ale łatwy przy użyciu polecenia curl.
Krok 1: Pobieranie danych za pomocą 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
Krok 2: Wygeneruj plik PDF za pomocą IronPDF
IronPDF to potężna biblioteka zaprojektowana do renderowania HTML, CSS, JavaScript i obrazów do dokumentów PDF o wysokiej jakości. Zapewnia pełną obsługę nowoczesnych standardów internetowych i zawiera funkcje takie jak dodawanie nagłówków, stopek oraz ustawianie określonych opcji renderowania.
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")
Wynik

Scenariusz: Eksportowanie JSON do Excela
Jeśli Twoja aplikacja korzysta z kanału JSON, możesz pobrać go za pomocą funkcji testowych CurlDotNet i wyeksportować za pomocą IronXL.
Krok 1: Pobieranie danych JSON za pomocą Curl-Dot-Net
Używamy Fluent Builder do tworzenia przejrzystego kodu .NET w celu pobrania pliku 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
Krok 2: Załaduj i wyeksportuj do Excela za pomocą IronXL
IronXL to kompleksowa biblioteka .NET przeznaczona do obsługi wszystkich aspektów odczytu, zapisu i manipulacji formatami plików Excel (.xlsx, .xls, .csv). Co najważniejsze, robi to bez konieczności instalowania pakietu Microsoft Office na serwerze lub komputerze klienckim, co czyni go idealnym rozwiązaniem dla środowisk wieloplatformowych Linux oraz CI/CD. Kluczowe funkcje obejmują pełną obsługę tworzenia wykresów, stosowania formuł i formatowania komórek.
Gdy surowe dane JSON znajdują się już w postaci ciągu znaków, można użyć IronXL do ich analizy i utworzenia arkusza kalkulacyjnego.
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))
Plik wyjściowy w formacie Excel

Dlaczego właśnie ta kombinacja?
-
Spójność między platformami: Zarówno produkty CurlDotNet, jak i IronSoftware obsługują systemy Windows, Linux i macOS. Ma to kluczowe znaczenie dla potoków CI/CD działających w środowiskach uruchomieniowych, takich jak Microsoft Azure lub AWS Lambda.
-
Generowanie kodu: Programiści często otrzymują fragmenty kodu do generowania w formacie bash lub shell. curl-dot-net pozwala na bezpośrednie wykorzystanie tych fragmentów kodu, podczas gdy Iron Software zajmuje się żmudną pracą związaną z przetwarzaniem dokumentów.
- Brak zależności od środowiska natywnego: Ponieważ CurlDotNet jest implementacją w czystym C#, unika się typowych problemów związanych z łączeniem zewnętrznych bibliotek C++ lub plików binarnych libcurl w różnych wersjach systemów operacyjnych.
Wnioski
Jacob Mellor stworzył niezbędne narzędzie dla społeczności DotNet. Umożliwiając programistom korzystanie ze znanych opcji curl w aplikacjach .NET Framework i .NET Core, CurlDotNet upraszcza proces wysyłania żądań HTTP. W połączeniu z oprogramowaniem Iron Software można stworzyć płynny przepływ pracy: pobierać dane z precyzją curl i przetwarzać je z wykorzystaniem możliwości IronPDF lub IronXL.
W razie napotkania problemów prosimy o zgłaszanie błędów na stronie GitHub, aby pomóc w ulepszaniu wsparcia dla wszystkich użytkowników.
Często Zadawane Pytania
Czym jest CurlDotNet?
CurlDotNet to biblioteka stworzona przez Jacoba Mellora w celu wprowadzenia funkcjonalności cURL do ekosystemu .NET, umożliwiająca programistom łatwe przekształcanie poleceń cURL na kod .NET.
W jaki sposób CurlDotNet pomaga programistom?
CurlDotNet pomaga programistom, upraszczając proces przekształcania operacji wiersza poleceń cURL na żądania HTTP w języku C#, co ułatwia integrację skryptów narzędzi wiersza poleceń z solidnymi aplikacjami .NET.
Jakie problemy rozwiązuje CurlDotNet?
CurlDotNet rozwiązuje problem, z którym borykają się programiści, próbując przekształcić działające polecenia cURL w odpowiednie żądania HTTP w języku C#. Oferuje znane podejście dla osób przyzwyczajonych do prostoty cURL.
Czy CurlDotNet może być używany z IronPDF?
Tak, CurlDotNet może być używany razem z IronPDF, aby ułatwić wysyłanie żądań HTTP w ramach procesów generowania plików PDF w aplikacjach .NET.
Czy CurlDotNet jest odpowiedni dla początkujących?
Tak, CurlDotNet jest odpowiedni dla początkujących, ponieważ zapewnia znany interfejs w stylu wiersza poleceń, który ułatwia naukę osobom, które dopiero zaczynają przygodę z .NET i żądaniami HTTP.
Jakie są zalety korzystania z CurlDotNet w połączeniu z IronPDF?
Wykorzystanie CurlDotNet wraz z IronPDF pozwala programistom usprawnić żądania HTTP podczas generowania plików PDF, zwiększając wydajność i wykorzystując mocne strony obu narzędzi.
Gdzie mogę dowiedzieć się więcej o CurlDotNet?
Więcej informacji na temat CurlDotNet można znaleźć w artykule Jacoba Mellora opublikowanym na platformie Medium, który zawiera szczegółowe informacje na temat tego, w jaki sposób biblioteka ta wypełnia lukę między poleceniami cURL a kodem .NET.




