C# HttpClient (Wie es für Entwickler funktioniert)
Die HttpClient-Klasse, Teil des .NET-Frameworks, bietet Methoden zum Senden von HTTP-Anfragen und Empfangen von HTTP-Antworten von einer durch eine URI identifizierten Ressource. Es vereinfacht das Erstellen von HTTP-Anfragen, egal ob Sie GET-, POST-, PUT- oder DELETE-Anfragen durchführen. Diese Anleitung behandelt den grundlegenden Einsatz von HttpClient in praktischen Szenarien und führt in die IronPDF-Bibliothek ein.
Erstellen einer neuen HttpClient-Instanz
Die HttpClient-Klasse wird verwendet, um HTTP-Anfragen zu senden. Sie können eine neue Instanz davon wie folgt erstellen:
using System;
using System.Net.Http;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
using var client = new HttpClient(); // Create a new instance of HttpClient
// Send a GET request to the specified URI and store the HTTP response
var response = await client.GetAsync("https://api.weatherapi.com/v1/current.json?key=YOUR_API_KEY&q=London");
// Retrieve the response content as a string
var responseBody = await response.Content.ReadAsStringAsync();
// Print the response content to the console
Console.WriteLine(responseBody);
}
}
using System;
using System.Net.Http;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
using var client = new HttpClient(); // Create a new instance of HttpClient
// Send a GET request to the specified URI and store the HTTP response
var response = await client.GetAsync("https://api.weatherapi.com/v1/current.json?key=YOUR_API_KEY&q=London");
// Retrieve the response content as a string
var responseBody = await response.Content.ReadAsStringAsync();
// Print the response content to the console
Console.WriteLine(responseBody);
}
}
Imports System
Imports System.Net.Http
Imports System.Threading.Tasks
Friend Class Program
Shared Async Function Main(ByVal args() As String) As Task
Dim client = New HttpClient() ' Create a new instance of HttpClient
' Send a GET request to the specified URI and store the HTTP response
Dim response = Await client.GetAsync("https://api.weatherapi.com/v1/current.json?key=YOUR_API_KEY&q=London")
' Retrieve the response content as a string
Dim responseBody = Await response.Content.ReadAsStringAsync()
' Print the response content to the console
Console.WriteLine(responseBody)
End Function
End Class
In diesem Beispiel:
- Es wird eine neue HttpClient-Instanz mit
var client = new HttpClient()erstellt. - Es wird eine HTTP-GET-Anfrage mit der Methode
GetAsyncgesendet. - Der Code
HttpResponseMessageist invar responsegespeichert. - Der Inhalt der Antwort wird mit
response.Content.ReadAsStringAsync()abgerufen.
Senden von HTTP-Anfragen
HTTP GET-Anfrage
Um eine HTTP-GET-Anfrage zu stellen und die Antwort zu behandeln:
using System;
using System.Net.Http;
using System.Threading.Tasks;
class Example
{
static async Task Main(string[] args)
{
var client = new HttpClient();
var response = await client.GetAsync("https://api.weatherapi.com/v1/current.json?key=YOUR_API_KEY&q=Paris");
// Check if the request was successful
if (response.IsSuccessStatusCode)
{
var responseBody = await response.Content.ReadAsStringAsync();
Console.WriteLine(responseBody);
}
}
}
using System;
using System.Net.Http;
using System.Threading.Tasks;
class Example
{
static async Task Main(string[] args)
{
var client = new HttpClient();
var response = await client.GetAsync("https://api.weatherapi.com/v1/current.json?key=YOUR_API_KEY&q=Paris");
// Check if the request was successful
if (response.IsSuccessStatusCode)
{
var responseBody = await response.Content.ReadAsStringAsync();
Console.WriteLine(responseBody);
}
}
}
Imports System
Imports System.Net.Http
Imports System.Threading.Tasks
Friend Class Example
Shared Async Function Main(ByVal args() As String) As Task
Dim client = New HttpClient()
Dim response = Await client.GetAsync("https://api.weatherapi.com/v1/current.json?key=YOUR_API_KEY&q=Paris")
' Check if the request was successful
If response.IsSuccessStatusCode Then
Dim responseBody = Await response.Content.ReadAsStringAsync()
Console.WriteLine(responseBody)
End If
End Function
End Class
- Die Eigenschaft
IsSuccessStatusCodestellt sicher, dass die Anfrage erfolgreich war. - Der Antworttext wird asynchron mit
ReadAsStringAsync()gelesen.
HTTP POST-Anfrage
Das Senden einer POST-Anfrage umfasst das Hinzufügen eines Anfragekörpers:
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
class Example
{
static async Task Main(string[] args)
{
var client = new HttpClient();
var requestBody = new StringContent("{ \"location\": \"New York\" }", Encoding.UTF8, "application/json");
// Send the POST request with the specified body
var response = await client.PostAsync("https://api.weatherapi.com/v1/forecast.json?key=YOUR_API_KEY", requestBody);
// Check if the request was successful
if (response.IsSuccessStatusCode)
{
var responseBody = await response.Content.ReadAsStringAsync();
Console.WriteLine(responseBody);
}
}
}
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
class Example
{
static async Task Main(string[] args)
{
var client = new HttpClient();
var requestBody = new StringContent("{ \"location\": \"New York\" }", Encoding.UTF8, "application/json");
// Send the POST request with the specified body
var response = await client.PostAsync("https://api.weatherapi.com/v1/forecast.json?key=YOUR_API_KEY", requestBody);
// Check if the request was successful
if (response.IsSuccessStatusCode)
{
var responseBody = await response.Content.ReadAsStringAsync();
Console.WriteLine(responseBody);
}
}
}
Imports System
Imports System.Net.Http
Imports System.Text
Imports System.Threading.Tasks
Friend Class Example
Shared Async Function Main(ByVal args() As String) As Task
Dim client = New HttpClient()
Dim requestBody = New StringContent("{ ""location"": ""New York"" }", Encoding.UTF8, "application/json")
' Send the POST request with the specified body
Dim response = Await client.PostAsync("https://api.weatherapi.com/v1/forecast.json?key=YOUR_API_KEY", requestBody)
' Check if the request was successful
If response.IsSuccessStatusCode Then
Dim responseBody = Await response.Content.ReadAsStringAsync()
Console.WriteLine(responseBody)
End If
End Function
End Class
PostAsyncsendet die Anfrage mit dem angegebenen Body (requestBody).- Der Inhaltstyp muss spezifiziert werden (application/json).
HTTP PUT Anfrage
Eine HTTP-PUT-Anfrage aktualisiert Ressourcen:
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
class Example
{
static async Task Main(string[] args)
{
var client = new HttpClient();
var requestBody = new StringContent("{ \"location\": \"Tokyo\", \"days\": 3 }", Encoding.UTF8, "application/json");
// Send a PUT request to update the resource
var response = await client.PutAsync("https://api.weatherapi.com/v1/forecast.json?key=YOUR_API_KEY", requestBody);
// Check if the request was successful
if (response.IsSuccessStatusCode)
{
var responseBody = await response.Content.ReadAsStringAsync();
Console.WriteLine(responseBody);
}
}
}
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
class Example
{
static async Task Main(string[] args)
{
var client = new HttpClient();
var requestBody = new StringContent("{ \"location\": \"Tokyo\", \"days\": 3 }", Encoding.UTF8, "application/json");
// Send a PUT request to update the resource
var response = await client.PutAsync("https://api.weatherapi.com/v1/forecast.json?key=YOUR_API_KEY", requestBody);
// Check if the request was successful
if (response.IsSuccessStatusCode)
{
var responseBody = await response.Content.ReadAsStringAsync();
Console.WriteLine(responseBody);
}
}
}
Imports System
Imports System.Net.Http
Imports System.Text
Imports System.Threading.Tasks
Friend Class Example
Shared Async Function Main(ByVal args() As String) As Task
Dim client = New HttpClient()
Dim requestBody = New StringContent("{ ""location"": ""Tokyo"", ""days"": 3 }", Encoding.UTF8, "application/json")
' Send a PUT request to update the resource
Dim response = Await client.PutAsync("https://api.weatherapi.com/v1/forecast.json?key=YOUR_API_KEY", requestBody)
' Check if the request was successful
If response.IsSuccessStatusCode Then
Dim responseBody = Await response.Content.ReadAsStringAsync()
Console.WriteLine(responseBody)
End If
End Function
End Class
PutAsyncsendet eine PUT-Anfrage, um die Ressource unter der angegebenen URI zu aktualisieren.- Der Anfragekörper enthält typischerweise die zu aktualisierenden Daten.
HTTP DELETE Anfrage
Um eine HTTP-DELETE-Anfrage zu senden:
using System;
using System.Net.Http;
using System.Threading.Tasks;
class Example
{
static async Task Main(string[] args)
{
var client = new HttpClient();
// Send a DELETE request to remove the resource
var response = await client.DeleteAsync("https://api.weatherapi.com/v1/locations/1?key=YOUR_API_KEY");
// Check if the request was successful
if (response.IsSuccessStatusCode)
{
Console.WriteLine("Resource deleted successfully");
}
}
}
using System;
using System.Net.Http;
using System.Threading.Tasks;
class Example
{
static async Task Main(string[] args)
{
var client = new HttpClient();
// Send a DELETE request to remove the resource
var response = await client.DeleteAsync("https://api.weatherapi.com/v1/locations/1?key=YOUR_API_KEY");
// Check if the request was successful
if (response.IsSuccessStatusCode)
{
Console.WriteLine("Resource deleted successfully");
}
}
}
Imports System
Imports System.Net.Http
Imports System.Threading.Tasks
Friend Class Example
Shared Async Function Main(ByVal args() As String) As Task
Dim client = New HttpClient()
' Send a DELETE request to remove the resource
Dim response = Await client.DeleteAsync("https://api.weatherapi.com/v1/locations/1?key=YOUR_API_KEY")
' Check if the request was successful
If response.IsSuccessStatusCode Then
Console.WriteLine("Resource deleted successfully")
End If
End Function
End Class
DeleteAsyncsendet eine DELETE-Anfrage zum Entfernen der Ressource.
Handhabung von HTTP-Antworten
Jede HTTP-Anfrage gibt ein HttpResponseMessage-Objekt zurück, das den Antworttext, Header und Statuscode enthält. Zum Beispiel:
using System;
using System.Net.Http;
using System.Threading.Tasks;
class Example
{
static async Task Main(string[] args)
{
var client = new HttpClient();
var response = await client.GetAsync("https://api.weatherapi.com/v1/current.json?key=YOUR_API_KEY&q=Sydney");
// Check if the request was successful
if (response.IsSuccessStatusCode)
{
var responseBody = await response.Content.ReadAsStringAsync();
Console.WriteLine(responseBody);
}
else
{
Console.WriteLine($"Error: {response.StatusCode}");
}
}
}
using System;
using System.Net.Http;
using System.Threading.Tasks;
class Example
{
static async Task Main(string[] args)
{
var client = new HttpClient();
var response = await client.GetAsync("https://api.weatherapi.com/v1/current.json?key=YOUR_API_KEY&q=Sydney");
// Check if the request was successful
if (response.IsSuccessStatusCode)
{
var responseBody = await response.Content.ReadAsStringAsync();
Console.WriteLine(responseBody);
}
else
{
Console.WriteLine($"Error: {response.StatusCode}");
}
}
}
Imports System
Imports System.Net.Http
Imports System.Threading.Tasks
Friend Class Example
Shared Async Function Main(ByVal args() As String) As Task
Dim client = New HttpClient()
Dim response = Await client.GetAsync("https://api.weatherapi.com/v1/current.json?key=YOUR_API_KEY&q=Sydney")
' Check if the request was successful
If response.IsSuccessStatusCode Then
Dim responseBody = Await response.Content.ReadAsStringAsync()
Console.WriteLine(responseBody)
Else
Console.WriteLine($"Error: {response.StatusCode}")
End If
End Function
End Class
Response.StatusCodeliefert den Statuscode (z. B. 200, 404).response.Contententhält den Antworttext, der asynchron mitReadAsStringAsync()gelesen werden kann.
Effiziente Nutzung von HttpClient
HttpClient-Instanzen sollten wiederverwendet werden, um von der Verbindungsaufteilung zu profitieren und eine Erschöpfung der Systemressourcen zu vermeiden. Ein typisches Muster besteht darin, eine einzige HttpClient-Instanz für die Lebensdauer Ihrer Anwendung oder Ihres Dienstes zu erstellen. Dies kann mit einer statischen Variable oder einer Abhängigkeitsinjektion für Webanwendungen erfolgen.
Statisches HttpClient-Beispiel
public static class HttpClientProvider
{
private static readonly HttpClient client = new HttpClient();
public static HttpClient Client => client;
}
public static class HttpClientProvider
{
private static readonly HttpClient client = new HttpClient();
public static HttpClient Client => client;
}
Public Module HttpClientProvider
'INSTANT VB NOTE: The field client was renamed since Visual Basic does not allow fields to have the same name as other class members:
Private ReadOnly client_Conflict As New HttpClient()
Public ReadOnly Property Client() As HttpClient
Get
Return client_Conflict
End Get
End Property
End Module
Die HttpClient-Instanz wird in der gesamten Anwendung wiederverwendet, um den Overhead neuer HTTP-Verbindungen zu reduzieren.
Verwendung von HttpClient mit Dependency Injection
In einer Webanwendung besteht der empfohlene Ansatz darin, HttpClient als Singleton-Service zu registrieren:
public void ConfigureServices(IServiceCollection services)
{
services.AddHttpClient();
}
public void ConfigureServices(IServiceCollection services)
{
services.AddHttpClient();
}
Public Sub ConfigureServices(ByVal services As IServiceCollection)
services.AddHttpClient()
End Sub
Sie können auch benannte Clients und typisierte Clients für spezifischere Konfigurationen erstellen.
Verbindungspooling und Proxy-Einstellungen
Durch die Wiederverwendung von HttpClient-Instanzen profitieren Sie von der Verbindungspoolbildung, was die Leistung mehrerer Anfragen an denselben Server verbessert. Proxy-Einstellungen können auch mit der HttpClientHandler-Klasse konfiguriert werden:
using System.Net;
using System.Net.Http;
var handler = new HttpClientHandler
{
Proxy = new WebProxy("http://proxyserver:port"), // Set the proxy server
UseProxy = true
};
var client = new HttpClient(handler);
using System.Net;
using System.Net.Http;
var handler = new HttpClientHandler
{
Proxy = new WebProxy("http://proxyserver:port"), // Set the proxy server
UseProxy = true
};
var client = new HttpClient(handler);
Imports System.Net
Imports System.Net.Http
Private handler = New HttpClientHandler With {
.Proxy = New WebProxy("http://proxyserver:port"),
.UseProxy = True
}
Private client = New HttpClient(handler)
Fehlerbehandlung und Status Codes
Um verschiedene HTTP-Statuscodes zu behandeln, überprüfen Sie die Eigenschaft HttpResponseMessage.StatusCode:
using System;
using System.Net;
using System.Net.Http;
using System.Threading.Tasks;
async Task MakeRequestAsync()
{
try
{
using var client = new HttpClient();
var response = await client.GetAsync("https://api.weatherapi.com/v1/current.json?key=YOUR_API_KEY&q=Berlin");
// Handle the response based on the status code
switch (response.StatusCode)
{
case HttpStatusCode.OK:
Console.WriteLine("Success");
var content = await response.Content.ReadAsStringAsync();
Console.WriteLine($"Response content: {content}");
break;
case HttpStatusCode.NotFound:
Console.WriteLine("Resource not found");
break;
case HttpStatusCode.Unauthorized:
Console.WriteLine("Unauthorized access");
break;
case HttpStatusCode.InternalServerError:
Console.WriteLine("Server error occurred");
break;
default:
Console.WriteLine($"Unexpected status code: {response.StatusCode}");
break;
}
}
catch (HttpRequestException e)
{
Console.WriteLine($"Request error: {e.Message}");
}
catch (Exception e)
{
Console.WriteLine($"An error occurred: {e.Message}");
}
}
using System;
using System.Net;
using System.Net.Http;
using System.Threading.Tasks;
async Task MakeRequestAsync()
{
try
{
using var client = new HttpClient();
var response = await client.GetAsync("https://api.weatherapi.com/v1/current.json?key=YOUR_API_KEY&q=Berlin");
// Handle the response based on the status code
switch (response.StatusCode)
{
case HttpStatusCode.OK:
Console.WriteLine("Success");
var content = await response.Content.ReadAsStringAsync();
Console.WriteLine($"Response content: {content}");
break;
case HttpStatusCode.NotFound:
Console.WriteLine("Resource not found");
break;
case HttpStatusCode.Unauthorized:
Console.WriteLine("Unauthorized access");
break;
case HttpStatusCode.InternalServerError:
Console.WriteLine("Server error occurred");
break;
default:
Console.WriteLine($"Unexpected status code: {response.StatusCode}");
break;
}
}
catch (HttpRequestException e)
{
Console.WriteLine($"Request error: {e.Message}");
}
catch (Exception e)
{
Console.WriteLine($"An error occurred: {e.Message}");
}
}
Imports System
Imports System.Net
Imports System.Net.Http
Imports System.Threading.Tasks
Async Function MakeRequestAsync() As Task
Try
Dim client = New HttpClient()
Dim response = Await client.GetAsync("https://api.weatherapi.com/v1/current.json?key=YOUR_API_KEY&q=Berlin")
' Handle the response based on the status code
Select Case response.StatusCode
Case HttpStatusCode.OK
Console.WriteLine("Success")
Dim content = Await response.Content.ReadAsStringAsync()
Console.WriteLine($"Response content: {content}")
Case HttpStatusCode.NotFound
Console.WriteLine("Resource not found")
Case HttpStatusCode.Unauthorized
Console.WriteLine("Unauthorized access")
Case HttpStatusCode.InternalServerError
Console.WriteLine("Server error occurred")
Case Else
Console.WriteLine($"Unexpected status code: {response.StatusCode}")
End Select
Catch e As HttpRequestException
Console.WriteLine($"Request error: {e.Message}")
Catch e As Exception
Console.WriteLine($"An error occurred: {e.Message}")
End Try
End Function
JSON-Antwortkörper-Behandlung
Sie arbeiten häufig mit JSON-Antworten. Sie können den Antwortinhalt in ein stark typisiertes Objekt deserialisieren:
using System;
using System.Net.Http;
using System.Text.Json;
using System.Threading.Tasks;
class Example
{
static async Task Main(string[] args)
{
var client = new HttpClient();
var response = await client.GetAsync("https://api.weatherapi.com/v1/current.json?key=YOUR_API_KEY&q=London");
var jsonString = await response.Content.ReadAsStringAsync();
// Deserialize the JSON response into a WeatherResponse object
var weatherResponse = JsonSerializer.Deserialize<WeatherResponse>(jsonString);
Console.WriteLine($"Location: {weatherResponse.Location}, Temperature: {weatherResponse.Temperature}");
}
}
public class WeatherResponse
{
public string Location { get; set; }
public double Temperature { get; set; }
}
using System;
using System.Net.Http;
using System.Text.Json;
using System.Threading.Tasks;
class Example
{
static async Task Main(string[] args)
{
var client = new HttpClient();
var response = await client.GetAsync("https://api.weatherapi.com/v1/current.json?key=YOUR_API_KEY&q=London");
var jsonString = await response.Content.ReadAsStringAsync();
// Deserialize the JSON response into a WeatherResponse object
var weatherResponse = JsonSerializer.Deserialize<WeatherResponse>(jsonString);
Console.WriteLine($"Location: {weatherResponse.Location}, Temperature: {weatherResponse.Temperature}");
}
}
public class WeatherResponse
{
public string Location { get; set; }
public double Temperature { get; set; }
}
Imports System
Imports System.Net.Http
Imports System.Text.Json
Imports System.Threading.Tasks
Friend Class Example
Shared Async Function Main(ByVal args() As String) As Task
Dim client = New HttpClient()
Dim response = Await client.GetAsync("https://api.weatherapi.com/v1/current.json?key=YOUR_API_KEY&q=London")
Dim jsonString = Await response.Content.ReadAsStringAsync()
' Deserialize the JSON response into a WeatherResponse object
Dim weatherResponse = JsonSerializer.Deserialize(Of WeatherResponse)(jsonString)
Console.WriteLine($"Location: {weatherResponse.Location}, Temperature: {weatherResponse.Temperature}")
End Function
End Class
Public Class WeatherResponse
Public Property Location() As String
Public Property Temperature() As Double
End Class
Die Methode ReadAsStringAsync() vereinfacht das direkte Einlesen von JSON-Inhalten in C#-Objekte.
Einführung in IronPDF

IronPDF ist eine .NET-PDF-Bibliothek, die zum Erstellen, Bearbeiten und Konvertieren von PDF-Dateien in C# entwickelt wurde. Es wird häufig für die Erstellung von hochwertigen PDFs aus HTML, CSS, JavaScript und anderen Formaten verwendet. IronPDF bietet Funktionen wie die HTML-zu-PDF-Konvertierung, das Mischen von PDFs, Wasserzeichen und sogar fortgeschrittene Operationen wie digitale Signaturen und PDF-Verschlüsselung. Es ist mit verschiedenen Plattformen kompatibel, einschließlich Windows, Linux und macOS, was es zu einer vielseitigen Lösung für plattformübergreifende Entwicklung macht.
Verwendung von IronPDF mit HttpClient
Das Kombinieren von IronPDF mit der HttpClient-Klasse in C# ist eine effektive Möglichkeit, PDF-Dokumente dynamisch aus Webressourcen zu erstellen und zu bearbeiten. Zum Beispiel können Sie HTML-Inhalte über eine URL mit HttpClient abrufen und diese dann mit IronPDF in ein PDF-Dokument konvertieren. Dies ist nützlich bei der Erstellung von Berichten, Rechnungen oder Dokumenten, die dynamisch auf Basis von aktuellen Webinhalten erstellt werden.
using System;
using System.Net.Http;
using System.Text.Json;
using System.Threading.Tasks;
using IronPdf;
class Program
{
static async Task Main(string[] args)
{
License.LicenseKey = "YOUR_LICENSE_KEY"; // Set your IronPDF license key
using var client = new HttpClient();
var response = await client.GetAsync("https://api.weatherapi.com/v1/forecast.json?key=YOUR_API_KEY&q=London&days=3");
// Check if the request was successful
if (response.IsSuccessStatusCode)
{
var jsonContent = await response.Content.ReadAsStringAsync();
var jsonElement = JsonSerializer.Deserialize<JsonElement>(jsonContent);
// Format the JSON content for pretty-printing
var formattedJson = JsonSerializer.Serialize(jsonElement, new JsonSerializerOptions { WriteIndented = true });
// Escape the JSON for HTML
formattedJson = System.Web.HttpUtility.HtmlEncode(formattedJson);
// Create an HTML string for PDF generation
var htmlContent = $@"
<html>
<head>
<style>
body {{ font-family: Arial, sans-serif; }}
pre {{ background-color: #f4f4f4; padding: 20px; border-radius: 5px; white-space: pre-wrap; word-wrap: break-word; }}
</style>
</head>
<body>
<h1>Weather Forecast (JSON Data)</h1>
<pre>{formattedJson}</pre>
</body>
</html>";
// Generate the PDF from the HTML content
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(htmlContent);
// Save the PDF to a file
pdf.SaveAs("F://weather_report.pdf");
Console.WriteLine("PDF generated successfully!");
}
else
{
Console.WriteLine($"Failed to retrieve content. Status code: {response.StatusCode}");
}
}
}
using System;
using System.Net.Http;
using System.Text.Json;
using System.Threading.Tasks;
using IronPdf;
class Program
{
static async Task Main(string[] args)
{
License.LicenseKey = "YOUR_LICENSE_KEY"; // Set your IronPDF license key
using var client = new HttpClient();
var response = await client.GetAsync("https://api.weatherapi.com/v1/forecast.json?key=YOUR_API_KEY&q=London&days=3");
// Check if the request was successful
if (response.IsSuccessStatusCode)
{
var jsonContent = await response.Content.ReadAsStringAsync();
var jsonElement = JsonSerializer.Deserialize<JsonElement>(jsonContent);
// Format the JSON content for pretty-printing
var formattedJson = JsonSerializer.Serialize(jsonElement, new JsonSerializerOptions { WriteIndented = true });
// Escape the JSON for HTML
formattedJson = System.Web.HttpUtility.HtmlEncode(formattedJson);
// Create an HTML string for PDF generation
var htmlContent = $@"
<html>
<head>
<style>
body {{ font-family: Arial, sans-serif; }}
pre {{ background-color: #f4f4f4; padding: 20px; border-radius: 5px; white-space: pre-wrap; word-wrap: break-word; }}
</style>
</head>
<body>
<h1>Weather Forecast (JSON Data)</h1>
<pre>{formattedJson}</pre>
</body>
</html>";
// Generate the PDF from the HTML content
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(htmlContent);
// Save the PDF to a file
pdf.SaveAs("F://weather_report.pdf");
Console.WriteLine("PDF generated successfully!");
}
else
{
Console.WriteLine($"Failed to retrieve content. Status code: {response.StatusCode}");
}
}
}
Imports System
Imports System.Net.Http
Imports System.Text.Json
Imports System.Threading.Tasks
Imports IronPdf
Friend Class Program
Shared Async Function Main(ByVal args() As String) As Task
License.LicenseKey = "YOUR_LICENSE_KEY" ' Set your IronPDF license key
Dim client = New HttpClient()
Dim response = Await client.GetAsync("https://api.weatherapi.com/v1/forecast.json?key=YOUR_API_KEY&q=London&days=3")
' Check if the request was successful
If response.IsSuccessStatusCode Then
Dim jsonContent = Await response.Content.ReadAsStringAsync()
Dim jsonElement = JsonSerializer.Deserialize(Of JsonElement)(jsonContent)
' Format the JSON content for pretty-printing
Dim formattedJson = JsonSerializer.Serialize(jsonElement, New JsonSerializerOptions With {.WriteIndented = True})
' Escape the JSON for HTML
formattedJson = System.Web.HttpUtility.HtmlEncode(formattedJson)
' Create an HTML string for PDF generation
Dim htmlContent = $"
<html>
<head>
<style>
body {{ font-family: Arial, sans-serif; }}
pre {{ background-color: #f4f4f4; padding: 20px; border-radius: 5px; white-space: pre-wrap; word-wrap: break-word; }}
</style>
</head>
<body>
<h1>Weather Forecast (JSON Data)</h1>
<pre>{formattedJson}</pre>
</body>
</html>"
' Generate the PDF from the HTML content
Dim renderer = New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
' Save the PDF to a file
pdf.SaveAs("F://weather_report.pdf")
Console.WriteLine("PDF generated successfully!")
Else
Console.WriteLine($"Failed to retrieve content. Status code: {response.StatusCode}")
End If
End Function
End Class

Denken Sie daran, 'YOUR_API_KEY' mit einem API-Schlüssel zu ersetzen, wenn Sie eine echte Wetter-API verwenden.
Abschluss

Dieses Tutorial hat die Verwendung der HttpClient-Klasse in C# zum Senden von HTTP-Anfragen und zum Behandeln von Antworten untersucht. Wir haben auch IronPDF eingeführt, eine leistungsstarke Bibliothek zur Generierung von PDFs in .NET-Anwendungen. Wir haben demonstriert, wie man diese Technologien kombiniert, indem man HTML-Inhalte von einem Webdienst mit HttpClient abruft und mit IronPDF in PDF konvertiert.
IronPDF bietet eine kostenlose Testversion an, und die Lizenzen beginnen bei $999, was es zu einem wertvollen Werkzeug für Entwickler macht, die umfassende PDF-Generierungsfunktionen benötigen.
Häufig gestellte Fragen
Wie kann ich HTML-Inhalte in PDF in C# umwandeln?
Sie können IronPDF verwenden, um HTML-Inhalte in PDF umzuwandeln, indem Sie dessen Methoden wie RenderHtmlAsPdf nutzen. Dies ermöglicht es Ihnen, HTML-Strings zusammen mit CSS und JavaScript einfach in professionelle PDF-Dokumente zu transformieren.
Wie kombiniere ich HttpClient mit der PDF-Erstellung in C#?
Durch die Integration von HttpClient mit IronPDF können Sie HTML-Inhalte von Web-Ressourcen abrufen und dann die Inhalte mit den Konvertierungsmethoden von IronPDF in PDF-Dokumente umwandeln. Dies ist besonders nützlich für die Erstellung von Berichten oder Rechnungen aus Echtzeitdaten.
Was ist die Wichtigkeit der Wiederverwendung von HttpClient-Instanzen?
Das Wiederverwenden von HttpClient-Instanzen ist entscheidend für ein effizientes Ressourcenmanagement. Es nutzt Connection-Pooling, um den Aufwand für das Erstellen neuer Verbindungen für jede Anfrage zu minimieren, was die Performance von Anwendungen verbessert.
Wie kann ich JSON-Antworten in C# deserialisieren?
In C# können JSON-Antworten mit der JsonSerializer-Klasse deserialisiert werden. Nachdem Sie den Antwortinhalt als String abgerufen haben, können Sie JsonSerializer.Deserialize verwenden, um ihn in ein stark typisiertes C#-Objekt zu konvertieren.
Was sind die bewährten Vorgehensweisen für den Umgang mit HTTP-Statuscodes in C#?
Der Umgang mit HTTP-Statuscodes in C# beinhaltet das Überprüfen der StatusCode-Eigenschaft des HttpResponseMessage. Verwenden Sie bedingte Anweisungen, um spezifische Codes wie HttpStatusCode.OK oder HttpStatusCode.NotFound zu verwalten, um eine angemessene Fehlerbehandlung zu implementieren.
Wie verbessert IronPDF .NET-Anwendungen mit PDF-Fähigkeiten?
IronPDF verbessert .NET-Anwendungen, indem es leistungsstarke Werkzeuge zum Erstellen, Bearbeiten und Konvertieren von PDF-Dateien bereitstellt. Es unterstützt die Erstellung hochqualitativer PDFs aus HTML, CSS und JavaScript und bietet Entwicklern die Möglichkeit, dynamische Dokumente mit Leichtigkeit zu erstellen.
Kann ich HttpClient verwenden, um HTML-Inhalte für die PDF-Konvertierung abzurufen?
Ja, HttpClient kann HTML-Inhalte von Web-Ressourcen abrufen, die dann mit IronPDF in ein PDF umgewandelt werden können. Dieser Ansatz ist hervorragend geeignet, um PDFs aus Live-Webdaten oder dynamischen Inhalten zu generieren.
Wie konfiguriere ich Proxy-Einstellungen für HttpClient in C#?
Um Proxy-Einstellungen für HttpClient zu konfigurieren, können Sie die HttpClientHandler-Klasse verwenden. Setzen Sie die Proxy-Eigenschaft auf eine WebProxy-Instanz und aktivieren Sie die UseProxy-Option beim Erstellen der HttpClient-Instanz.




