.NET-HILFE

RestSharp C# (Wie es für Entwickler funktioniert)

Regan Pun

14. Januar 2024

Teilen Sie:

Einführung

RestSharp ist eine beliebte Open-Source-.NET-Bibliothek für die Erstellung von HTTP-Anfragen in C#. Es vereinfacht die Arbeit mit RESTful-APIs und bietet eine unkomplizierte und flexible Möglichkeit zur Kommunikation mit Webdiensten. In diesem Artikel werden wir die wichtigsten Merkmale vonRestSharp undIronPDF und demonstrieren, wie Sie Daten extrahieren und ein PDF erzeugen können.

Warum RestSharp?

In modernen, mehrschichtigen Anwendungen müssen verschiedene Dienste sehr oft miteinander kommunizieren, und RestSharp bietet einen einfachen und effizienten Weg, indem es alle Komplexitäten kapselt. Dies vereinfacht den Softwareentwicklungsprozess erheblich.

RestSharp installieren

RestSharp ist erhältlich alsNuGet paket und kann in Ihrem C#-Projekt installiert werden. Sie können dies mit der NuGet Package Manager Console oder derVisual Studio NuGet Package Manager UI.

Install-Package RestSharp

Einfache GET-Anfragen stellen

Beginnen wir mit einem einfachen Beispiel für eine GET-Anforderung 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()
    {
        // Create a RestClient instance
        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)
        {
            // Output the response body content
            Console.WriteLine(response.Content);
        }
        else
        {
            // Handle the error
            Console.WriteLine($"Error: {response.ErrorMessage}");
        }
    }
    public void LogData(string msg)
    {
        Console.WriteLine(msg)
    }
}

using RestSharp;
namespace rest_sharp_demo;
class Program
{
    static void Main()
    {
        // Create a RestClient instance
        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)
        {
            // Output the response body content
            Console.WriteLine(response.Content);
        }
        else
        {
            // Handle the error
            Console.WriteLine($"Error: {response.ErrorMessage}");
        }
    }
    public void LogData(string msg)
    {
        Console.WriteLine(msg)
    }
}

Imports RestSharp
Namespace rest_sharp_demo
	Friend Class Program
		Shared Sub Main()
			' Create a RestClient instance
			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
				' Output the response body content
				Console.WriteLine(response.Content)
			Else
				' Handle the error
				Console.WriteLine($"Error: {response.ErrorMessage}")
			End If
		End Sub
		Public Sub LogData(ByVal msg As String)
			Console.WriteLine(msg)
		End Sub
	End Class
End Namespace

RestSharp unterstützt auch asynchrone Anfragen und Antworten unter Verwendung der asynchronen API-Methoden.

Umgang mit 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 Klasse "User" mit Eigenschaften definiert, die den JSON-Feldern entsprechen. Wir haben JsonSerializer.Deserialize aus dem System.Text.Json.Serialization 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 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.

RestSharp C#(Wie es für Entwickler funktioniert): Abbildung 1 - Konsolenausgabe, die alle Benutzer-IDs und Namen anzeigt.

Der gesamte Code ist in Git verfügbarunter diesem Link.

Art des Inhalts

RestSharp unterstützt das Senden von XML- oder JSON-Body-Anfragen. die Methoden AddJsonBody oder AddXmlBody** der Instanz RestRequest können verwendet werden, um einen JSON- oder XML-Body hinzuzufügen. RestSharp legt den Inhaltstyp automatisch fest.

RestSharp verarbeitet JSON- oder XML-Antworten automatisch.

//using RestSharp;
// 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);

//using RestSharp;
// 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);

'using RestSharp;
' 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)

Senden von Daten mit POST-Anforderungen

RestSharp unterstützt auch das Senden von Daten im Request Body, was bei der Erstellung oder Aktualisierung von Ressourcen üblich ist. Ändern wir unser Beispiel, um eine POST-Anfrage-API zu demonstrieren:

using RestSharp;
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);
if (response.IsSuccessful)
{
// Output the response content
    Console.WriteLine(response.Content);
}
else
{
    Console.WriteLine($"Error: {response.ErrorMessage}");
}

using RestSharp;
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);
if (response.IsSuccessful)
{
// Output the response content
    Console.WriteLine(response.Content);
}
else
{
    Console.WriteLine($"Error: {response.ErrorMessage}");
}

Imports RestSharp
Private client = New RestClient("https://jsonplaceholder.typicode.com/users")
' New user object
Private newUser = New User With {
	.Name = "John Doe",
	.Email = "john.doe@example.com"
}
' Serialize the user object to JSON
Private jsonBody = JsonSerializer.Serialize(newUser)
' Create a RestRequest for the POST method with the JSON request body
Private request = (New RestRequest()).AddJsonBody(jsonBody)
If response.IsSuccessful Then
' Output the response content
	Console.WriteLine(response.Content)
Else
	Console.WriteLine($"Error: {response.ErrorMessage}")
End If

In diesem Beispiel erstellen wir ein neues "User"-Objekt, serialisieren es zu JSON und fügen es mit der Methode AddJsonBody in den Anfragekörper ein. Der Server empfängt die JSON-Daten und verarbeitet die Anfrage entsprechend.

Ausgabe

RestSharp C#(Wie es für Entwickler funktioniert): Abbildung 2 - Konsolenausgabe

Authentifizierung

RestSharp unterstützt auch das Senden von Anfragen mit Authentifizierung. Die RestClientOptions können 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 eine einfache geheime Client-ID-Authentifizierung, die bei jeder Anfrage gesendet wird.

Fehlerbehandlung

RestSharp kann Fehler behandeln, die bei URL-Anfragen auftreten, wie z. B. Timeout-, Authentifizierungs- oder Autorisierungsfehler. RestSharp wirft keine Ausnahme, wenn die Anfrage automatisch fehlschlägt. Sie muss manuell konfiguriert werden.

Die folgenden Fehlerbehandlungskonfigurationen können vorgenommen werden:

FailOnDeserializationError: Wenn Sie diese Eigenschaft auf true setzen, wird RestSharp angewiesen, eine fehlgeschlagene Deserialisierung als Fehler zu betrachten und den ResponseStatus entsprechend auf Error zu setzen.
ThrowOnDeserializationError: Wenn Sie diese Eigenschaft auf true setzen, wird RestSharp einen Fehler werfen, wenn die Deserialisierung fehlschlägt.
ThrowOnAnyError: Wirft eine Ausnahme, wenn bei einer Anfrage oder bei der Deserialisierung ein Fehler auftritt.

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 vonIron Software die beim Lesen und Erzeugen von PDF-Dokumenten hilft. Es kann leicht formatierte Dokumente mit Stilinformationen in PDF umwandeln. IronPDF kann problemlos PDFs aus HTML-Inhalten erzeugen; die Software kann den HTML-Code von einer URL herunterladen und dann PDFs generieren.

Ein Hauptmerkmal von IronPDF istUmwandlung von HTML in PDFdabei bleiben alle Ihre Layouts und Stile erhalten. Es wandelt Webinhalte in PDF-Dateien um und ist damit ideal für Berichte, Rechnungen und Dokumentationen. HTML-Dateien, URLs und HTML-Strings können problemlos in PDFs umgewandelt werden.

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        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)
    {
        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)
		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 mit Hilfe des NuGet-Paketmanagers in Ihr Selenium RestSharp-Projekt zu integrieren, gehen Sie folgendermaßen vor:

Öffnen Sie Visual Studio, und klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf Ihr Projekt.
Wählen Sie "NuGet-Pakete verwalten..." aus dem Kontextmenü.
Gehen Sie auf die 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 die Aufforderung zu einer Lizenzvereinbarung.
Wenn Sie IronPDF über die Paketmanager-Konsole in Ihr Projekt einbinden möchten, führen Sie den folgenden Befehl in der Paketmanager-Konsole aus:

Install-Package IronPdf

Es wird IronPDF in Ihr Projekt holen und installieren.

Installation über die NuGet-Website

Einen detaillierten Überblick über IronPDF, einschließlich seiner Funktionen, Kompatibilität und zusätzlicher Download-Optionen, finden Sie auf der IronPDF-Seite auf der NuGet-Website unter https://www.nuget.org/packages/IronPdf.

Installation über DLL

Alternativ können Sie IronPDF auch direkt in Ihr Projekt einbinden, indem Sie die DLL-Datei verwenden. Laden Sie die ZIP-Datei, die die DLL enthält, herunter vonIronPDF Downloads. Entpacken Sie die Datei und binden Sie die DLL in Ihr Projekt ein.

Jetzt werden wir alle Benutzer erfassen und einen PDF-Bericht mithilfe eines HTML-Strings und des IronPDF-Generators erstellen.

using System.Text.Json;
using System.Text.Json.Serialization;
using RestSharp;
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}");
        }
    }
    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;
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}");
        }
    }
    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
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
'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>
    "
	ignore ignore ignore ignore var footer = "
</body>
</html>"
	ignore ignore var 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>
"
	ignore ignore ignore ignore ignore ignore ignore ignore ignore ignore ignore
			Next user
			htmlContent += footer
			Return htmlContent
		End Function
	End Class
End Namespace

Der gesamte Code ist in Git zu findenunter diesem Link.

Hier generieren 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 den HTML-String in ein PDF-Dokument zu konvertieren. Das erzeugte Dokument sieht wie folgt aus:

RestSharp C#(Wie es für Entwickler funktioniert): Abbildung 4 - PDF-Ausgabe

Das Dokument ist mit einem kleinen Wasserzeichen für Testlizenzen versehen, das mit einer gültigen Lizenz entfernt werden kann.

Lizenzierung (kostenlose Testversion verfügbar)

Damit der obige Code funktioniert, ist ein Lizenzschlüssel erforderlich. Dieser Schlüssel muss in appsettings.json platziert werden.

"IronPdf.LicenseKey": "your license key"

"IronPdf.LicenseKey": "your license key"

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'"IronPdf.LicenseKey": "your license key"

Atestlizenz ist für Entwickler nach der Registrierung verfügbar, und für eine Testlizenz ist keine Kreditkarte erforderlich. Man kann seine E-Mail-ID angeben und sich für eine kostenlose Testversion registrieren.

Schlussfolgerung

Die RestSharp-Bibliothek vereinfacht die Arbeit mit RESTful-APIs in C# und bietet eine saubere und effiziente Möglichkeit, HTTP-Anfragen zu stellen und Antworten zu verarbeiten. Egal, ob Sie Daten mit GET-Anfragen abrufen oder mit POST-Anfragen senden, die intuitive API und die praktischen Funktionen von RestSharp machen es zu einem wertvollen Werkzeug für Entwickler, die Anwendungen erstellen, die mit Webservices interagieren.

IronPDF bietet eine flexible und einfach zu bedienende Lösung für die Erstellung von PDFs. Weitere Informationen zu den verschiedenen IronPDF-Funktionen finden Sie auf derIronPDF-Dokumentationsseite.

IronPDFs immerwährendelizenzen wird Ihnen helfen, Ihre Programmierkenntnisse zu verbessern und moderne Anwendungsanforderungen zu erfüllen.

Die Kenntnis von RestSharp und IronPDF ist eine große Bereicherung und ermöglicht es Entwicklern, moderne Anwendungen zu erstellen.

Regan Pun

Jetzt mit dem Ingenieurteam chatten

Software-Ingenieur

Regan schloss sein Studium an der University of Reading mit einem BA in Elektrotechnik ab. Bevor er zu Iron Software kam, konzentrierte er sich in seinen früheren Jobs auf einzelne Aufgaben. Was ihm bei Iron Software am meisten Spaß macht, ist das Spektrum der Aufgaben, die er übernehmen kann, sei es im Vertrieb, im technischen Support, in der Produktentwicklung oder im Marketing. Es macht ihm Spaß, die Art und Weise zu verstehen, wie Entwickler die Bibliothek von Iron Software nutzen, und dieses Wissen zu nutzen, um die Dokumentation und die Produkte kontinuierlich zu verbessern.

< PREVIOUS
Zusammenführen von PDF-Dateien in .NET

NÄCHSTES >
Test Konsolenanwendung C# (Wie es für Entwickler funktioniert)