Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF
  2. IronPDF Blog
  3. .NET Unterstützung
  4. RestSharp in C#
.NET HILFE

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

Jacob Mellor, Chief Technology Officer @ Team Iron
Jacob Mellor
Aktualisiert:

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
$vbLabelText   $csharpLabel

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
$vbLabelText   $csharpLabel

In 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 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
$vbLabelText   $csharpLabel

Ausgabe

Alle Benutzer-IDs und Namen werden in der Ausgabe angezeigt.

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

Der gesamte Code ist in Git unter diesem Link verfügbar.

Inhaltstyp

RestSharp unterstützt das Senden von XML- oder JSON-Body-Anfragen. Die AddJsonBody- oder AddXmlBody-Methoden der RestRequest-Instanz können verwendet werden, um einen JSON- oder XML-Body 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
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)
$vbLabelText   $csharpLabel

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
$vbLabelText   $csharpLabel

In diesem Beispiel erstellen wir ein neues User-Objekt, serialisieren es in JSON und fügen es mit der AddJsonBody-Methode in den Anfragetext 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)}
$vbLabelText   $csharpLabel

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 diese Eigenschaft auf true gesetzt ist, wird RestSharp angewiesen, fehlgeschlagene Deserialisierung als Fehler zu betrachten und den ResponseStatus entsprechend auf Error zu setzen.
  • ThrowOnDeserializationError: Wenn diese Eigenschaft auf true gesetzt ist, wird RestSharp angewiesen, bei fehlgeschlagener Deserialisierung eine Ausnahme zu werfen.
  • ThrowOnAnyError: Wirft eine Ausnahme, wenn bei der Anfrage oder während 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)
$vbLabelText   $csharpLabel

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
$vbLabelText   $csharpLabel

IronPDF-Bibliothek installieren

Um IronPDF in Ihr Selenium RestSharp-Projekt über den NuGet Package Manager zu integrieren, führen Sie folgende Schritte durch:

  1. Öffnen Sie Visual Studio und klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf Ihr Projekt.
  2. Wählen Sie im Kontextmenü "NuGet-Pakete verwalten..." aus.
  3. Gehen Sie zur Registerkarte "Durchsuchen" und suchen Sie nach IronPDF.
  4. Wählen Sie die IronPDF-Bibliothek aus den Suchergebnissen aus und klicken Sie auf die Schaltfläche Installieren.
  5. 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
$vbLabelText   $csharpLabel

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 RenderHtmlAsPdf-Methode, um den HTML-String in ein PDF-Dokument zu konvertieren. Das generierte Dokument sieht wie folgt aus:

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

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 in appsettings.json wie folgt 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.

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.

Jacob Mellor, Chief Technology Officer @ Team Iron
Jacob Mellor
  Jetzt mit dem Ingenieurteam chatten
Chief Technology Officer

Jacob Mellor ist Chief Technology Officer bei Iron Software und ein visionärer Ingenieur, der führend in der C# PDF-Technologie ist. Als ursprünglicher Entwickler der Iron Software-Kerncodebasis hat er die Produktarchitektur des Unternehmens seit seiner Gründung gestaltet und zusammen mit CEO Cameron Rimington in ein Unternehmen ...

Weiterlesen

Verwandte Artikel

30-Tage-Testversion → Volles Produkt. Keine Grenzen. Keine Karte. Gratis testen