RestSharp ist eine beliebte Open-Source-.NET-Bibliothek zum Erstellen von HTTP-Anfragen in C#. Es vereinfacht den Umgang mit RESTful-APIs und bietet eine unkomplizierte und flexible Möglichkeit, mit Webdiensten zu kommunizieren. In diesem Artikel werden wir die wichtigsten Funktionen von RestSharp und IronPDF untersuchen und demonstrieren, wie Sie Daten extrahieren und ein PDF generieren können.
In modernen Multi-Tier-Anwendungen müssen verschiedene Dienste sehr oft miteinander kommunizieren, und RestSharp bietet eine einfache und effiziente Möglichkeit, indem es alle Komplexitäten kapselt. Dies vereinfacht den Softwareentwicklungsprozess erheblich.
RestSharp ist als NuGet-Paket verfügbar und kann in Ihr C#-Projekt installiert werden. Dies können Sie mit der NuGet-Paket-Manager-Konsole oder der NuGet-Paket-Manager-UI von Visual Studio tun.
Beginnen wir mit einem einfachen Beispiel für eine GET-Anfrage an eine RESTful-API mit RestSharp. Angenommen, wir möchten Informationen von einer öffentlichen ASP.NET Core-API abrufen, die Benutzerdaten zurückgibt:
using RestSharp;
namespace rest_sharp_demo
{
class Program
{
static void Main()
{
// Base URL for the REST API
var baseUrl = "https://jsonplaceholder.typicode.com/users";
// Create a RestClientOptions with default credentials
var options = new RestClientOptions(baseUrl) { UseDefaultCredentials = true };
var client = new RestClient(options);
// Create a RestRequest for the GET method
var request = new RestRequest();
// Execute the request and get the response
var response = client.Get(request);
// Check if the request was successful
if (response.IsSuccessful)
{
// Output the response body content
Console.WriteLine(response.Content);
}
else
{
// Handle the error
Console.WriteLine($"Error: {response.ErrorMessage}");
}
}
// Additional method to log data
public void LogData(string msg)
{
Console.WriteLine(msg);
}
}
}Imports RestSharp
Namespace rest_sharp_demo
Class Program
Shared Sub Main()
' Base URL for the REST API
Dim baseUrl = "https://jsonplaceholder.typicode.com/users"
' Create a RestClientOptions with default credentials
Dim options = New RestClientOptions(baseUrl) With {
.UseDefaultCredentials = True
}
Dim client = New RestClient(options)
' Create a RestRequest for the GET method
Dim request = New RestRequest()
' Execute the request and get the response
Dim response = client.Get(request)
' Check if the request was successful
If response.IsSuccessful Then
' Output the response body content
Console.WriteLine(response.Content)
Else
' Handle the error
Console.WriteLine($"Error: {response.ErrorMessage}")
End If
End Sub
' Additional method to log data
Public Sub LogData(msg As String)
Console.WriteLine(msg)
End Sub
End Class
End NamespaceRestSharp unterstützt auch asynchrone Anfragen und Antworten mit den Async-API-Methoden.
RestSharp bietet praktische Methoden zur Deserialisierung von Antwortinhalten in C#-Objekte. Erweitern wir unser Beispiel, um die JSON-Antwortdaten in eine Liste von Benutzerobjekten zu deserialisieren:
// Deserialize JSON response into a list of User objects
var users = JsonSerializer.Deserialize<List<User>>(response.Content);
// Output user information
foreach (var user in users)
{
Console.WriteLine($"User ID: {user.Id}, Name: {user.Name}, Email: {user.Email}");
}' Deserialize JSON response into a list of User objects
Dim users = JsonSerializer.Deserialize(Of List(Of User))(response.Content)
' Output user information
For Each user In users
Console.WriteLine($"User ID: {user.Id}, Name: {user.Name}, Email: {user.Email}")
Next userIn diesem Beispiel haben wir eine User-Klasse mit Eigenschaften definiert, die den JSON-Feldern entsprechen. Wir haben JsonSerializer.Deserialize aus dem System.Text.Json-Namespace verwendet.
public class User
{
[JsonPropertyName("company")]
public Company Company { get; set; }
[JsonPropertyName("id")]
public int Id { get; set; }
[JsonPropertyName("phone")]
public string Phone { get; set; }
[JsonPropertyName("website")]
public string Website { get; set; }
[JsonPropertyName("name")]
public string Name { get; set; }
[JsonPropertyName("username")]
public string Username { get; set; }
[JsonPropertyName("email")]
public string Email { get; set; }
[JsonPropertyName("address")]
public Address Address { get; set; }
}Public Class User
<JsonPropertyName("company")>
Public Property Company As Company
<JsonPropertyName("id")>
Public Property Id As Integer
<JsonPropertyName("phone")>
Public Property Phone As String
<JsonPropertyName("website")>
Public Property Website As String
<JsonPropertyName("name")>
Public Property Name As String
<JsonPropertyName("username")>
Public Property Username As String
<JsonPropertyName("email")>
Public Property Email As String
<JsonPropertyName("address")>
Public Property Address As Address
End ClassAlle Benutzer-IDs und Namen werden in der Ausgabe angezeigt.
Der gesamte Code ist in Git unter diesem Link verfügbar.
RestSharp unterstützt das Senden von XML- oder JSON-Body-Anfragen. Die AddJsonBody- oder AddXmlBody-Methoden der RestRequest-Instanz können verwendet werden, um JSON- oder XML-Körper hinzuzufügen. RestSharp setzt den Inhaltstyp automatisch. Es behandelt JSON- oder XML-Antworten automatisch.
// Serialize the user object to JSON
var jsonBodyString = JsonSerializer.Serialize(newUser);
// Create a RestRequest for the POST method with the JSON request data
var requestData = new RestRequest().AddJsonBody(jsonBodyString);
var response = client.ExecutePost(requestData);' Serialize the user object to JSON
Dim jsonBodyString = JsonSerializer.Serialize(newUser)
' Create a RestRequest for the POST method with the JSON request data
Dim requestData = (New RestRequest()).AddJsonBody(jsonBodyString)
Dim response = client.ExecutePost(requestData)RestSharp unterstützt auch das Senden von Daten im Anfragetext, was üblich ist, wenn Ressourcen erstellt oder aktualisiert werden. Ändern wir unser Beispiel, um eine POST-Anfrage-API zu demonstrieren:
using RestSharp;
using System.Text.Json;
namespace rest_sharp_demo
{
class Program
{
static void Main()
{
var client = new RestClient("https://jsonplaceholder.typicode.com/users");
// New user object
var newUser = new User
{
Name = "John Doe",
Email = "john.doe@example.com"
};
// Serialize the user object to JSON
var jsonBody = JsonSerializer.Serialize(newUser);
// Create a RestRequest for the POST method with the JSON request body
var request = new RestRequest().AddJsonBody(jsonBody);
// Execute the POST request
var response = client.ExecutePost(request);
// Check if the request was successful
if (response.IsSuccessful)
{
// Output the response content
Console.WriteLine(response.Content);
}
else
{
Console.WriteLine($"Error: {response.ErrorMessage}");
}
}
}
}Imports RestSharp
Imports System.Text.Json
Namespace rest_sharp_demo
Class Program
Shared Sub Main()
Dim client = New RestClient("https://jsonplaceholder.typicode.com/users")
' New user object
Dim newUser = New User With {
.Name = "John Doe",
.Email = "john.doe@example.com"
}
' Serialize the user object to JSON
Dim jsonBody = JsonSerializer.Serialize(newUser)
' Create a RestRequest for the POST method with the JSON request body
Dim request = New RestRequest().AddJsonBody(jsonBody)
' Execute the POST request
Dim response = client.ExecutePost(request)
' Check if the request was successful
If response.IsSuccessful Then
' Output the response content
Console.WriteLine(response.Content)
Else
Console.WriteLine($"Error: {response.ErrorMessage}")
End If
End Sub
End Class
End NamespaceIn diesem Beispiel erstellen wir ein neues User-Objekt, serialisieren es zu JSON und fügen es dem Anforderungskörper mithilfe der AddJsonBody-Methode hinzu. Der Server empfängt die JSON-Daten und verarbeitet die Anfrage entsprechend.
RestSharp unterstützt auch das Senden von Anfragen mit Authentifizierung. Die RestClientOptions kann Authentifizierungsparameter enthalten.
var options = new RestClientOptions("https://auth.net")
{
Authenticator = new HttpBasicAuthenticator(_clientId, _clientSecret)
};Dim options = New RestClientOptions("https://auth.net") With {.Authenticator = New HttpBasicAuthenticator(_clientId, _clientSecret)}Hier verwenden wir die grundlegende Client-ID-Secret-Authentifizierung, die bei jeder Anfrage gesendet wird.
RestSharp kann Fehler behandeln, die während URL-Anfragen auftreten, wie z. B. Timeout-, Authentifizierungs- oder Autorisierungsfehler. RestSharp löst keine Ausnahme aus, wenn die Anfrage automatisch fehlschlägt. Es muss manuell konfiguriert werden.
Die folgenden Fehlerbehandlungskonfigurationen können vorgenommen werden:
ResponseStatus entsprechend auf Error zu setzen.var restClientOptions = new RestClientOptions(url)
{
ThrowOnAnyError = true
};
var client = new RestClient(restClientOptions);Dim restClientOptions As New RestClientOptions(url) With {.ThrowOnAnyError = True}
Dim client = New RestClient(restClientOptions)IronPDF ist eine C#-PDF-Bibliothek von Iron Software, die beim Lesen und Erstellen von PDF-Dokumenten hilft. Es kann einfach formatierte Dokumente mit Stilinformationen in PDF konvertieren. IronPDF kann ganz einfach PDFs aus HTML-Inhalten erstellen; es kann HTML von einer URL herunterladen und dann PDFs erstellen.
Ein Hauptmerkmal von IronPDF ist die HTML-zu-PDF-Konvertierung, die alle Ihre Layouts und Stile bewahrt. Es verwandelt Webinhalte in PDFs und ist damit ideal für Berichte, Rechnungen und Dokumentationen. HTML-Dateien, URLs und HTML-Strings können problemlos in PDFs konvertiert werden.
using IronPdf;
class Program
{
static void Main(string[] args)
{
// Create a PDF renderer using Chrome
var renderer = new ChromePdfRenderer();
// 1. Convert HTML String to PDF
var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");
// 2. Convert HTML File to PDF
var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");
// 3. Convert URL to PDF
var url = "http://ironpdf.com"; // Specify the URL
var pdfFromUrl = renderer.RenderUrlAsPdf(url);
pdfFromUrl.SaveAs("URLToPDF.pdf");
}
}Imports IronPdf
Friend Class Program
Shared Sub Main(ByVal args() As String)
' Create a PDF renderer using Chrome
Dim renderer = New ChromePdfRenderer()
' 1. Convert HTML String to PDF
Dim htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>"
Dim pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent)
pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf")
' 2. Convert HTML File to PDF
Dim htmlFilePath = "path_to_your_html_file.html" ' Specify the path to your HTML file
Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")
' 3. Convert URL to PDF
Dim url = "http://ironpdf.com" ' Specify the URL
Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
pdfFromUrl.SaveAs("URLToPDF.pdf")
End Sub
End ClassUm IronPDF in Ihr Selenium RestSharp-Projekt über den NuGet Package Manager zu integrieren, führen Sie folgende Schritte durch:
Wenn Sie IronPDF über die Paket-Manager-Konsole in Ihr Projekt einbinden möchten, führen Sie den folgenden Befehl in der Paket-Manager-Konsole aus:
Es wird IronPDF in Ihr Projekt holen und installieren.
Für einen detaillierten Überblick über IronPDF, einschließlich seiner Funktionen, Kompatibilität und zusätzlicher Download-Optionen, besuchen Sie die IronPDF-Seite auf der NuGet-Website unter https://www.nuget.org/packages/IronPdf.
Alternativ können Sie IronPDF direkt in Ihr Projekt integrieren, indem Sie die DLL-Datei verwenden. Laden Sie die ZIP-Datei herunter, die die DLL von IronPDF Downloads enthält. Entpacken Sie sie und fügen Sie die DLL in Ihr Projekt ein.
Jetzt holen wir alle Benutzer und erstellen einen PDF-Bericht mit einem HTML-String und dem IronPDF-Generator.
using System.Text.Json;
using System.Text.Json.Serialization;
using RestSharp;
using IronPdf;
namespace rest_sharp_demo
{
class Program
{
static void Main()
{
// Create a RestClient
var baseUrl = "https://jsonplaceholder.typicode.com/users";
RestClientOptions options = new RestClientOptions(baseUrl) { UseDefaultCredentials = true };
var client = new RestClient(options);
// Create a RestRequest for the GET method
var request = new RestRequest();
// Execute the request and get the response
var response = client.Get(request);
// Check if the request was successful
if (response.IsSuccessful)
{
// Deserialize JSON response into a list of User objects
var users = JsonSerializer.Deserialize<List<User>>(response.Content);
// Generate PDF
var html = GetHtml(users);
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("UsersReport.pdf");
}
else
{
// Handle the error
Console.WriteLine($"Error: {response.ErrorMessage}");
}
}
// Method to generate HTML from user data
private static string GetHtml(List<User>? users)
{
string header = @"
<html>
<head><title>Users List</title></head>
<body>
";
var footer = @"
</body>
</html>";
var htmlContent = header;
foreach (var user in users)
{
htmlContent += $@"
<h1>{user.Name}</h1>
<p>Username: {user.Username}</p>
<p>Email: {user.Email}</p>
<p>Company: {user.Company}</p>
<p>Phone: {user.Phone}</p>
<p>Website: {user.Website}</p>
<p>Suite: {user.Address.Suite}</p>
<p>Street: {user.Address.Street}</p>
<p>City: {user.Address.City}</p>
<p>Zipcode: {user.Address.Zipcode}</p>
";
}
htmlContent += footer;
return htmlContent;
}
}
}Imports System.Text.Json
Imports System.Text.Json.Serialization
Imports RestSharp
Imports IronPdf
Namespace rest_sharp_demo
Class Program
Shared Sub Main()
' Create a RestClient
Dim baseUrl = "https://jsonplaceholder.typicode.com/users"
Dim options As New RestClientOptions(baseUrl) With {.UseDefaultCredentials = True}
Dim client As New RestClient(options)
' Create a RestRequest for the GET method
Dim request As New RestRequest()
' Execute the request and get the response
Dim response = client.Get(request)
' Check if the request was successful
If response.IsSuccessful Then
' Deserialize JSON response into a list of User objects
Dim users = JsonSerializer.Deserialize(Of List(Of User))(response.Content)
' Generate PDF
Dim html = GetHtml(users)
Dim renderer = New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("UsersReport.pdf")
Else
' Handle the error
Console.WriteLine($"Error: {response.ErrorMessage}")
End If
End Sub
' Method to generate HTML from user data
Private Shared Function GetHtml(users As List(Of User)) As String
Dim header As String = "
<html>
<head><title>Users List</title></head>
<body>
"
Dim footer As String = "
</body>
</html>"
Dim htmlContent As String = header
For Each user In users
htmlContent += $"
<h1>{user.Name}</h1>
<p>Username: {user.Username}</p>
<p>Email: {user.Email}</p>
<p>Company: {user.Company}</p>
<p>Phone: {user.Phone}</p>
<p>Website: {user.Website}</p>
<p>Suite: {user.Address.Suite}</p>
<p>Street: {user.Address.Street}</p>
<p>City: {user.Address.City}</p>
<p>Zipcode: {user.Address.Zipcode}</p>
"
Next
htmlContent += footer
Return htmlContent
End Function
End Class
End NamespaceDer gesamte Code kann in Git unter diesem Link gefunden werden.
Hier erzeugen wir zunächst einen HTML-String aus der Benutzerliste mit allen für die Berichte erforderlichen Formatierungen. Dann verwenden wir IronPDF, um ein PDF-Dokument zu erstellen. Wir verwenden die RenderHtmlAsPdf-Methode, um den HTML-String in ein PDF-Dokument zu konvertieren. Das generierte Dokument sieht wie folgt aus:
Das Dokument hat ein kleines Wasserzeichen für Testlizenzen, das mit einer gültigen Lizenz entfernt werden kann.
Für das obige Codebeispiel ist ein Lizenzschlüssel erforderlich. Dieser Schlüssel muss wie folgt in appsettings.json platziert werden:
{
"IronPdf.LicenseKey": "your license key"
}Eine Testlizenz ist für Entwickler nach der Registrierung verfügbar, und es wird für eine Testlizenz keine Kreditkarte benötigt. Man kann seine E-Mail-ID angeben und sich für eine kostenlose Testversion registrieren.
Die RestSharp-Bibliothek vereinfacht den Umgang mit RESTful-APIs in C# und bietet eine saubere und effiziente Möglichkeit, HTTP-Anfragen zu erstellen und Antworten zu verarbeiten. Egal, ob Sie Daten mit GET-Anfragen abrufen oder Daten mit POST-Anfragen senden, RestSharps intuitive API und praktische Funktionen machen es zu einem wertvollen Werkzeug für Entwickler, die Anwendungen entwickeln, die mit Webdiensten interagieren.
IronPDF bietet eine flexible und benutzerfreundliche Lösung zur Erstellung von PDFs. Für zusätzliche Informationen zu verschiedenen IronPDF-Funktionen besuchen Sie bitte die IronPDF-Dokumentationsseite.
Die permanenten Lizenzen von IronPDF helfen Ihnen, Ihre Programmierfähigkeiten zu verbessern und moderne Anwendungsanforderungen zu erfüllen.
Das Wissen über sowohl RestSharp als auch IronPDF fügt großartige Fähigkeiten hinzu, die es Entwicklern ermöglichen, moderne Anwendungen zu erstellen.
Jacob Mellor ist Chief Technology Officer bei Iron Software und ein visionärer Ingenieur, der Pionierarbeit in der C# PDF-Technologie leistet. Als der ursprüngliche Entwickler hinter der Kern-Codebasis von Iron Software hat er die Produktarchitektur des Unternehmens seit seiner Gründung geprägt und es zusammen mit CEO Cameron Rimington in ein Unternehmen mit mehr als 50 Mitarbeitern verwandelt, das die NASA, Tesla und globale Regierungsbehörden beliefert.
IronPDF ist ein Teil der IRONSUITE
10 .NET-API-Produkte für Ihre Bürodokumente
Wenn Ihr PDF wie HTML aussehen soll, schnell.
