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 for .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.

How can you handle different HTTP status codes in C#?

You can handle different HTTP status codes by checking the HttpResponseMessage.StatusCode property and implementing logic for handling each specific status code as needed.

Can IronPDF be used to convert HTML retrieved via HttpClient into PDF format?

Yes, IronPDF can convert HTML content retrieved via HttpClient into PDF format, which is useful for generating dynamic reports or documents from live data.

Die C# PDF-Bibliothek

Explore IronPDF Gratis testen

HTML zu PDF

Online Demo Alle Codebeispiele anzeigen

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

PM >Install-Package IronPdf

Install-Package IronPdf

ENTWICKLER-UPDATES

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

Jacob Mellor

Updated: 21. April 2026

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

Module Program
    Async Function Main(args As String()) As Task
        Using client As 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 Using
    End Function
End Module

Imports System
Imports System.Net.Http
Imports System.Threading.Tasks

Module Program
    Async Function Main(args As String()) As Task
        Using client As 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 Using
    End Function
End Module

In diesem Beispiel:

Eine neue HttpClient-Instanz wird mit var client = new HttpClient() erstellt.
Eine HTTP-GET-Anfrage wird mit der Methode GetAsync gesendet.
Das HttpResponseMessage wird in var response gespeichert.
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

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 IsSuccessStatusCode stellt 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

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

PostAsync sendet die Anfrage mit dem angegebenen Körper (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

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

PutAsync sendet eine PUT-Anfrage, um die Ressource an 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

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

DeleteAsync sendet eine DELETE-Anfrage, um die Ressource zu entfernen.

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

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.StatusCode liefert den Statuscode (z.B. 200, 404).
response.Content enthält den Antworttext, der asynchron mit ReadAsStringAsync() 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

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

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)

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

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

Module Example
    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 Module

Public Class WeatherResponse
    Public Property Location As String
    Public Property Temperature As Double
End Class

Imports System
Imports System.Net.Http
Imports System.Text.Json
Imports System.Threading.Tasks

Module Example
    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 Module

Public Class WeatherResponse
    Public Property Location As String
    Public Property Temperature As Double
End Class

Die ReadAsStringAsync()-Methode vereinfacht das direkte Lesen von JSON-Inhalten in C#-Objekte.

Einführung in IronPDF

C# HttpClient (Funktionsweise für Entwickler): Abbildung 1 - 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}");
        }
    }
}

C# HttpClient (Funktionsweise für Entwickler): Abbildung 2 - PDF-Ausgabe

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 seine Lizenzen beginnen bei $999, was es zu einem wertvollen Werkzeug für Entwickler macht, die umfassende PDF-Generierungsfunktionen suchen.

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 Pionierarbeit in der C# PDF-Technologie leistet. Als der ursprüngliche Entwickler hinter der Kern-Codebasis von Iron Software hat er die Produktarchitektur des Unternehmens seit seiner Gründung geprägt und es zusammen mit CEO Cameron Rimington in ein Unternehmen mit mehr als 50 Mitarbeitern verwandelt, das die NASA, Tesla und globale Regierungsbehörden beliefert.

...