RestSharp C# (Wie es für Entwickler funktioniert)
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.
Warum RestSharp?
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 installieren
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.
Install-Package RestSharp
Einfache GET-Anfragen stellen
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);
}
}
}
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
Friend 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(ByVal msg As String)
Console.WriteLine(msg)
End Sub
End Class
End Namespace
RestSharp unterstützt auch asynchrone Anfragen und Antworten mit den Async-API-Methoden.
Verarbeitung von Antwortdaten
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
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 user
In diesem Beispiel haben wir eine User Klasse mit Eigenschaften definiert, die den JSON-Feldern entsprechen. Wir haben JsonSerializer.Deserialize aus dem Namespace System.Text.Json 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 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 Class
Ausgabe
Alle Benutzer-IDs und Namen werden in der Ausgabe angezeigt.

Der gesamte Code ist in Git unter diesem Link verfügbar.
Inhaltstyp
RestSharp unterstützt das Senden von XML- oder JSON-Body-Anfragen. Mit den Methoden AddJsonBody oder AddXmlBody der Instanz RestRequest kann ein JSON- oder XML-Body hinzugefügt werden. 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
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)
Datenversand mit POST-Anfragen
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}");
}
}
}
}
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
Friend 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 Namespace
In diesem Beispiel erstellen wir ein neues User-Objekt, serialisieren es in JSON und fügen es mithilfe der Methode AddJsonBody in den Anfragetext ein. Der Server empfängt die JSON-Daten und verarbeitet die Anfrage entsprechend.
Ausgabe

Authentifizierung
RestSharp unterstützt auch das Senden von Anfragen mit Authentifizierung. Der Code RestClientOptions kann Authentifizierungsparameter enthalten.
var options = new RestClientOptions("https://auth.net")
{
Authenticator = new HttpBasicAuthenticator(_clientId, _clientSecret)
};
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.
Fehlerbehandlung
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:
- FailOnDeserializationError: Wenn Sie diese Eigenschaft auf true setzen, weist RestSharp an, eine fehlgeschlagene Deserialisierung als Fehler zu betrachten und
ResponseStatusentsprechend aufErrorzu setzen. - ThrowOnDeserializationError: Wenn Sie diese Eigenschaft auf true setzen, wird RestSharp angewiesen, eine Ausnahme auszulösen, wenn die Deserialisierung fehlschlägt.
- ThrowOnAnyError: Wirft eine Ausnahme, wenn beim Senden einer Anfrage oder während der Deserialisierung Fehler auftreten.
var restClientOptions = new RestClientOptions(url)
{
ThrowOnAnyError = true
};
var client = new RestClient(restClientOptions);
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)
Einführung in IronPDF
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");
}
}
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 Class
IronPDF-Bibliothek installieren
Um IronPDF in Ihr Selenium RestSharp-Projekt über den NuGet Package Manager zu integrieren, führen Sie folgende Schritte durch:
- Öffnen Sie Visual Studio und klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf Ihr Projekt.
- Wählen Sie im Kontextmenü "NuGet-Pakete verwalten..." aus.
- Gehen Sie zur Registerkarte "Durchsuchen" und suchen Sie nach IronPDF.
- Wählen Sie die IronPDF-Bibliothek aus den Suchergebnissen aus und klicken Sie auf die Schaltfläche Installieren.
- Akzeptieren Sie alle Lizenzvereinbarungen.
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:
Install-Package IronPdf
Es wird IronPDF in Ihr Projekt holen und installieren.
Installation über NuGet Website
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.
Installation über DLL
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;
}
}
}
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
Friend 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 = 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
' 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
'INSTANT VB WARNING: Nullable reference types have no equivalent in VB:
'ORIGINAL LINE: private static string GetHtml(List<User>? users)
Private Shared Function GetHtml(ByVal users As List(Of User)) As String
Dim header As String = "
<html>
<head><title>Users List</title></head>
<body>
"
Dim footer = "
</body>
</html>"
Dim htmlContent = 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 user
htmlContent &= footer
Return htmlContent
End Function
End Class
End Namespace
Der 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 Methode RenderHtmlAsPdf, um die HTML-Zeichenkette in ein PDF-Dokument umzuwandeln. 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.
Lizenzierung (Kostenlose Testversion verfügbar)
Für das obige Codebeispiel ist ein Lizenzschlüssel erforderlich. Dieser Schlüssel muss wie folgt in appsettings.json eingefügt 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.
Abschluss
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.
Häufig gestellte Fragen
Wie kann ich HTML in PDF in C# konvertieren?
Sie können die RenderHtmlAsPdf-Methode von IronPDF verwenden, um HTML-Strings in PDFs zu konvertieren. Sie können auch HTML-Dateien mit RenderHtmlFileAsPdf in PDFs konvertieren.
Was ist RestSharp in C#?
RestSharp ist eine beliebte Open-Source .NET-Bibliothek zum Ausführen von HTTP-Anfragen in C#. Es vereinfacht die Arbeit mit RESTful-APIs, indem es eine einfache und flexible Möglichkeit bietet, mit Webdiensten zu kommunizieren.
Wie installiere ich RestSharp in einem C#-Projekt?
RestSharp kann als NuGet-Paket in Ihrem C#-Projekt installiert werden. Sie können dies mit der NuGet-Paket-Manager-Konsole mithilfe des Befehls Install-Package RestSharp oder über die Visual Studio NuGet-Paket-Manager-Benutzeroberfläche tun.
Wie kann ich PDFs aus API-Daten in C# generieren?
Sie können RestSharp verwenden, um Daten von einer API abzurufen und IronPDF, um diese Daten in ein PDF umzuwandeln. Zuerst holen Sie die Daten mit RestSharp ab und formatieren dann die Daten in HTML, das mit IronPDF in ein PDF konvertiert werden kann.
Was sind die besten Vorgehensweisen zur Fehlerbehandlung in RestSharp?
RestSharp bietet Mechanismen zur Fehlerbehandlung, indem es Ihnen ermöglicht, den Antwortstatus zu überprüfen und Ausnahmen zu behandeln. Sie können die Eigenschaften ResponseStatus und StatusCode inspizieren, um festzustellen, ob die Anfrage erfolgreich war oder ob ein Fehler aufgetreten ist.
Wie kann ich JSON-Daten in RestSharp-Antworten handhaben?
RestSharp kann JSON-Daten in Antworten problemlos verarbeiten. Es bietet Methoden, um JSON-Inhalte mit Bibliotheken wie System.Text.Json oder Newtonsoft.Json in C#-Objekte zu deserialisieren.
Können Sie URLs in PDFs mit C# konvertieren?
Ja, IronPDF ermöglicht es Ihnen, Web-URLs in PDFs zu konvertieren, indem Sie die Methode RenderUrlAsPdf verwenden, die den Inhalt der URL abruft und in ein PDF-Dokument umwandelt.
Wie sende ich Daten mit einer POST-Anfrage in RestSharp?
Um Daten mit einer POST-Anfrage in RestSharp zu senden, erstellen Sie ein neues Objekt, serialisieren es in JSON und fügen es mit der Methode AddJsonBody der RestRequest in den Anfragekörper ein. Anschließend führen Sie die POST-Anfrage mit dem Client aus.
Unterstützt RestSharp Authentifizierung?
Ja, RestSharp unterstützt das Senden von Anfragen mit Authentifizierung. Sie können Authentifizierungsparameter in den RestClientOptions einfügen, wie die Verwendung von HttpBasicAuthenticator für die Basis-Authentifizierung.
Wie kann ich die PDF-Erstellung in meine C#-Anwendung integrieren?
Sie können die PDF-Erstellung in Ihre C#-Anwendung mithilfe von IronPDF integrieren. Es erlaubt Ihnen, HTML-Inhalte, URLs oder HTML-Dateien in PDFs umzuwandeln, was nützlich für die Erstellung von Berichten, Dokumentationen oder Rechnungen direkt innerhalb einer Anwendung ist.




