Anleitung zur Verwendung eines Proxys mit HttpClient

Am Ende dieses HttpClient C#-Proxy-Integrationshandbuchs werden Sie wissen, wie es geht:

Was ist HttpClient und welche Rolle spielt es bei der Erstellung von HTTP-Anforderungen in .NET?
Warum Sie einen Proxy in C# verwenden sollten
Einrichten eines Proxys in HttpClient
Umgang mit Proxy-Authentifizierung, SSL-Zertifikatsfehlern und IP-Rotation mit HttpClient.

Lasst uns eintauchen!

Was ist HttpClient in .NET?

HttpClient ist eine Klasse für die Erstellung von HTTP-Anforderungen und den Empfang von HTTP-Antworten in .NET. Sie ist Teil des System.Net.Http-Namensraums und stellt den Standard-HTTP-Client in .NET – und damit in C# – dar.

HttpClient unterstützt:

Alle HTTP-Methoden, einschließlich GET, POST, PUT, PATCH und DELETE
Asynchrone Kommunikation
Kopfzeilen und Cookie-Anpassung
Körperanpassung anfordern
Integration von Proxys

Diese Funktionen sowie die offizielle Unterstützung in der .NET-Standardbibliothek machen HttpClient zu einer beliebten Wahl für HTTP-Anfragen in C#.

Warum Sie einen Proxy in C# HttpClient festlegen müssen

Bei der Arbeit mit Web Scraping, Datenerfassung oder anderen internetbezogenen Aufgaben ist der Schutz Ihrer Online-Identität von entscheidender Bedeutung. Eine Möglichkeit, dies zu erreichen, besteht darin, den Datenverkehr über einen Proxyserver zu leiten.

Ein Proxy-Server fungiert als Vermittler zwischen Ihnen und der Zielsite und bietet dem HttpClient diese Vorteile:

Versteckte IP und Standort: Die Zielserver sehen die IP des Proxys, nicht Ihre.
Erhöhte Vertraulichkeit: Proxys bieten einen zusätzlichen Schutz der Privatsphäre, indem sie Ihre tatsächliche Identität verschleiern und es schwieriger machen, Sie aufzuspüren.
Vermeiden Sie IP-Sperren: Proxys helfen Ihnen, Ratenbegrenzer zu umgehen, was beim Web Scraping mit C# von grundlegender Bedeutung ist.
Umgehen Sie geografische Beschränkungen: Sie können Proxy-Server in bestimmten Regionen nutzen, um von zu Hause aus auf geografisch eingeschränkte Inhalte zuzugreifen.

Die Verwendung von Proxys in HttpClient erhöht also nicht nur Ihre Online-Sicherheit, sondern auch die Zuverlässigkeit Ihrer Scraping-Aufgaben.

Einrichten eines Proxys mit HttpClient in C#: Schritt-für-Schritt-Anleitung

Führen Sie die folgenden Schritte aus, um zu erfahren, wie Sie einen Proxy in HttpClient in .NET mit C# integrieren.

Voraussetzungen

Bevor Sie beginnen, sollten Sie sicherstellen, dass Sie die folgenden Voraussetzungen erfüllen:

EINE C#-IDE: Sie können entweder Visual Studio oder Visual Studio Code verwenden. In diesem Leitfaden verwenden wir Visual Studio Code mit der C#-Erweiterung.
.NET 8+ lokal installiert haben: Sie benötigen die neueste Version von .NET oder eine LTS-Version größer oder gleich .NET 8. In diesem Lernprogramm wird .NET 9 verwendet.

Wenn Sie nicht über die erforderlichen Tools verfügen, laden Sie sie über den obigen Link herunter und folgen Sie dem Installationsassistenten.

Schritt 1: Projekt einrichten

Erstellen Sie einen neuen Ordner für Ihr .NET-Projekt und navigieren Sie im Terminal mit den folgenden Befehlen zu diesem Ordner:

mkdir httpclient-proxy
cd httpclient-proxy

Als Nächstes initialisieren Sie darin eine neue .NET-Konsolenanwendung:

dotnet run console

Die Ausgabe sollte sein:

The template "Console App" was created successfully.

Öffnen Sie nun den Projektordner in Ihrer IDE:

Sie sollten die von der Vorlage generierten Dateien sehen, wobei Program.cs die wichtigste ist. Derzeit enthält sie ein einfaches “Hello, World!”-Skript. Am Ende dieses Abschnitts wird es ein C#-HttpClient-Proxy-Integrationsskript sein.

Um sicherzustellen, dass alles wie erwartet funktioniert, versuchen Sie, die C#-Anwendung mit zu starten:

dotnet run

Das Ergebnis sollte sein:

Hello, World!

Großartig! Sie haben jetzt ein funktionierendes C#-Projekt in Visual Studio Code.

Schritt #2: HttpClient einrichten

Fügen Sie die folgenden Codezeilen zu Program.cs hinzu, um eine Anforderung mit HttpClient zu senden:

using System.Net;

class Program
{
  static async Task Main()
  {
    // initialize an HttpClient instance
    using HttpClient client = new HttpClient();

    // the target URL
    string url = "https://httpbin.org/ip";

    // send an async GET request to the endpoint
    HttpResponseMessage response = await client.GetAsync(url);

    // read the response content as a string
    string responseBody = await response.Content.ReadAsStringAsync();

    // print the response to the console
    Console.WriteLine(responseBody);
  }
}

Das Snippet initialisiert eine HttpClient-Instanz und verwendet deren GetAsync() -Methode, um eine Verbindung mit dem /ip GET-Endpunkt des HTTPBin.io-Projekts herzustellen. Diese API gibt die IP-Adresse des Aufrufers zurück und ist damit ein perfektes Ziel, um zu überprüfen, ob die Proxy-Integration wie erwartet funktioniert. Der Grund dafür? Sobald Sie einen Proxy in den HttpClient integrieren, muss sich die vom /ip-Endpunkt zurückgegebene IP von Ihrer ursprünglichen IP unterscheiden.

Wenn Sie das Skript ausführen, sollte die Ausgabe in etwa so aussehen:

{
  "origin": "55.17.80.196"
}

Die in origin enthaltene IP-Adresse stellt Ihre Exit-IP dar.

Erstaunlich! Zeit, eine gültige Proxy-URL zu erhalten.

Schritt #3: Abrufen eines Proxys

Um einen Proxy in den HttpClient zu integrieren, benötigen Sie zunächst Zugang zu einem Proxyserver.

Viele Online-Portale bieten kostenlose Proxy-URLs an, aber seien Sie vorsichtig – der Betrieb einer Proxy-Infrastruktur ist teuer. Wenn ein Dienst kostenlose Proxys anbietet, sollten Sie sich fragen, was das Geschäftsmodell dieses Dienstes sein könnte. Oft handelt es sich um Datendiebstahl oder andere fragwürdige Praktiken.

Aus diesem Grund ist es am besten, kostenlose Proxys nur zu Lernzwecken zu verwenden und sie für den Produktionseinsatz zu meiden!

Wenn Sie zuverlässige Proxys benötigen, sollten Sie seriöse Anbieter in Betracht ziehen, die kostenlose Testversionen oder begrenzte kostenlose Pläne anbieten. Sie können zum Beispiel unsere kostenlosen Proxys ausprobieren.

Eine typische Proxy-URL hat dieses Format:

<protocol>://<host>:<port>

Wo:

protocol gibt den Proxy-Typ an (z. B. http, https, socks5, usw.)
host: Die Domäne oder IP-Adresse des Proxy-Servers
Anschluss: Die Portnummer, über die der Verkehr geleitet wird

In diesem Beispiel wird angenommen, dass die Proxy-URL lautet:

http://66.29.154.103:3128

Speichern Sie dies in einer Variablen in Program.cs:

string proxyUrl = "http://66.29.154.103:3128";

Zeit zu sehen, wie man einen Proxy mit HttpClient verwendet!

Schritt #4: Proxy-Integration

HttpClient ermöglicht es Ihnen, einen Proxy über die Klasse HttpClientHandler anzugeben. Dies ermöglicht eine Kontrolle auf niedriger Ebene über HTTP-Anforderungen, die von einer HttpClient-Instanz gesendet werden.

Insbesondere hat HttpClientHandler eine Proxy-Eigenschaft, die ein WebProxy-Objekt mit Proxy-Server-Einstellungen akzeptiert:

WebProxy proxy = new WebProxy
{
  Address = new Uri(proxyUrl),
};

Dann übergeben Sie den Proxy an eine HttpClientHandler-Instanz:

HttpClientHandler handler = new HttpClientHandler
{
    Proxy = proxy,
};

Und schließlich übergeben Sie HttpClientHandler an den HttpClient-Konstruktor:

using HttpClient client = new HttpClient(handler);

Wunderbar! HttpClient C# Proxy-Integration abgeschlossen.

Schritt #5: Alles zusammenfügen

Ihr endgültiges Skript für die HttpClient-Proxy-Integration sollte Folgendes enthalten:

using System.Net;

class Program
{
  static async Task Main()
  {
    // initialize a new proxy object
    string proxyUrl = "http://66.29.154.103:3128"; // replace with a valid proxy URL
    WebProxy proxy = new WebProxy
    {
      Address = new Uri(proxyUrl),
    };

    // define an HTTP client handler with the given proxy
    HttpClientHandler handler = new HttpClientHandler
    {
      Proxy = proxy,
    };

    // initialize an HttpClient instance with proxy integration
    using HttpClient client = new HttpClient(handler);

    // the target URL
    string url = "https://httpbin.org/ip";

    // send an async GET request to the endpoint
    HttpResponseMessage response = await client.GetAsync(url);

    // read the response content as a string
    string responseBody = await response.Content.ReadAsStringAsync();

    // print the response to the console
    Console.WriteLine(responseBody);
  }
}

Führen Sie das Skript aus:

dotnet run

Das Ergebnis sollte sein:

{
  "origin": "66.29.154.103"
}

Beachten Sie, dass das Attribut origin in der Antwort des /ip-Endpunkts die IP-Adresse des Proxy-Servers anzeigt. Dies bestätigt, dass Ihre echte IP erfolgreich hinter dem Proxy verborgen wurde.

Warnung: Kostenlose Proxyserver sind in der Regel kurzlebig und unzuverlässig. Wenn Sie diese Anleitung lesen, wird der gewählte Proxy nicht mehr funktionieren. Um den Code zu testen, ersetzen Sie proxyUrl durch eine gültige, funktionierende Proxy-URL, bevor Sie das Skript ausführen.

Erweiterte Anwendungsfälle für die Integration von HttpClient-Proxys

Sie haben gerade die Grundlagen der Proxy-Integration mit HttpClient in C# gelernt, aber es gibt noch weitere fortgeschrittene Szenarien zu berücksichtigen.

Proxy-Authentifizierung

Premium-Proxys sind durch Authentifizierung geschützt, um den Zugriff auf autorisierte Benutzer zu beschränken. Die URL eines authentifizierten Proxys hat insbesondere folgendes Format:

<protocol>://<username>:<password>@<host>:<port>

Benutzername und Kennwort sind die für die Authentifizierung verwendeten Anmeldeinformationen.

In HttpClient wird die Proxy-Authentifizierung über die Credentials-Eigenschaft von WebProxy gehandhabt. Diese Eigenschaft akzeptiert ein NetworkCredential-Objekt wie folgt:

WebProxy proxy = new WebProxy
{
  Address = new Uri(proxyUrl),
  // specify proxy authentication
  Credentials = new NetworkCredential("<username>", "<password>"),
};

Auszug und aus Ihrer authentifizierten Proxy-URL und ersetzen Sie sie im obigen Code.

Der Code für die Integration eines authentifizierten Proxys wird also folgendermaßen aussehen:

using System.Net;

class Program
{
  static async Task Main()
  {
    // initialize a new proxy object
    string proxyUrl = "<protocol>://<host>:<port>";
    WebProxy proxy = new WebProxy
    {
      Address = new Uri(proxyUrl),
      // specify proxy authentication
      Credentials = new NetworkCredential("<username>", "<password>"),
    };

    // define an HTTP client handler with the given proxy
    HttpClientHandler handler = new HttpClientHandler
    {
      Proxy = proxy,
    };

    // initialize an HttpClient instance with authenticated proxy integration
    using HttpClient client = new HttpClient(handler);

    // the target URL
    string url = "https://httpbin.org/ip";

    // send an async GET request to the endpoint
    HttpResponseMessage response = await client.GetAsync(url);

    // read the response content as a string
    string responseBody = await response.Content.ReadAsStringAsync();

    // print the response to the console
    Console.WriteLine(responseBody);
  }
}

Vermeiden Sie Probleme mit SSL-Zertifikaten

Wenn Sie einen Proxy in HttpClient einrichten, können Ihre Anfragen aufgrund des unten aufgeführten Fehlers bei der Überprüfung des SSL-Zertifikats fehlschlagen:

Unhandled exception. System.Net.Http.HttpRequestException: The SSL connection could not be established, see inner exception.
 ---> System.Security.Authentication.AuthenticationException: The remote certificate is invalid because of errors in the certificate chain: UntrustedRoot

Dies geschieht normalerweise, wenn der Proxy ein selbstsigniertes SSL-Zertifikat verwendet.

Wenn Sie Ihrem Proxyserver vertrauen – und nur in diesem Fall – können Sie die SSL-Überprüfung deaktivieren, um dieses Problem mit dem folgenden Ansatz zu umgehen:

HttpClientHandler handler = new HttpClientHandler();
handler.ClientCertificateOptions = ClientCertificateOption.Manual;
handler.ServerCertificateCustomValidationCallback = (httpRequestMessage, cert, cetChain, policyErrors) =>
{
  return true;
};

using HttpClient client = new HttpClient(handler);

Das obige Snippet setzt das Standardverhalten der Zertifikatsvalidierung durch einen benutzerdefinierten Callback außer Kraft, der immer true zurückgibt.

Hinweis: Die Deaktivierung der SSL-Überprüfung macht Ihre Verbindung anfällig für MITM-Angriffe (Man-in-the-Middle). Verwenden Sie diesen Ansatz nur, wenn Sie Ihrem Proxy voll vertrauen und sich der Sicherheitsrisiken bewusst sind.

Proxy-Rotation implementieren

Wenn Sie sich wiederholt auf denselben Proxyserver verlassen, kann es passieren, dass die Zielseite ihre IP-Adresse blockiert. Um dies zu vermeiden, können Sie Ihre Proxyserver für jede Anfrage wechseln, so dass Ihre Anfragen jedes Mal einen anderen Proxyserver verwenden.

Gehen Sie wie folgt vor, um die Proxy-Rotation zu implementieren

Eine Liste mit vielen Proxy-URLs auffüllen
Zufällige Auswahl einer Proxy-URL vor jeder Anfrage
Festlegen der gewählten Proxy-URL im HttpClient

Der obige Algorithmus lässt sich in den folgenden Ausschnitt übersetzen:

using System.Net;

class Program
{  
  static async Task Main()
  {
    // get a random proxy URL
    string selectedProxyUrl = GetRandomProxyUrl();

    // configure the random proxy
    HttpClientHandler handler = new HttpClientHandler
    {
      Proxy = new WebProxy
      {
        Address = new Uri(selectedProxyUrl),
      },
    };

    // perform a GET request through the random proxy
    using HttpClient client = new HttpClient(handler);
    string url = "https://httpbin.org/ip";
    HttpResponseMessage response = await client.GetAsync(url);

    // read the response content as a string and print it
    string responseBody = await response.Content.ReadAsStringAsync();
    Console.WriteLine(responseBody);
  }

  static string GetRandomProxyUrl()
  {
    // the list of proxy URL to rotate from
    List<string> proxyUrls = new List<string>
        {
            "<protocol_1>://<proxy_host_1>:<port_1>",
            // ...
            "<protocol_n>://<proxy_host_n>:<port_n>",
        };

    // return a random proxy URL from the list
    Random random = new Random();
    int index = random.Next(proxyUrls.Count);
    return proxyUrls[index];
  }
}

Die Hauptnachteile dieses Ansatzes sind:

Es handelt sich um einen Standardcode
Es erfordert den Zugang zu einem Pool von zuverlässigen Proxy-Servern, was in der Regel mit Kosten verbunden ist

Glücklicherweise gibt es eine effizientere Lösung, um eine IP-Adresse in C# zu rotieren!

Bright Data bietet rotierende Proxys an, die die IP-Adressen der Ausgänge automatisch rotieren lassen, so dass eine manuelle Proxy-Rotation nicht erforderlich ist. Sie verfügen über rund 100 Millionen IPs, sind in 195 Ländern verfügbar, haben eine außergewöhnliche Netzwerkverfügbarkeit und garantieren eine Erfolgsquote von 99,9 %.

Im nächsten Kapitel erfahren Sie, wie Sie mit den rotierenden Proxys von Bright Data in HttpClient arbeiten können.

Verwendung eines Bright Data Proxy im HttpClient

Bright Data betreibt einen der größten Proxyserver der Welt, der Fortune-500-Unternehmen und über 20.000 Kunden bedient. Dieses weltweite Proxy-Netzwerk umfasst:

Rechenzentrums-Proxys – Über 770.000 Rechenzentrums-IPs.
Proxys für Privatpersonen – Über 72 Millionen private IPs in mehr als 195 Ländern.
ISP-Proxys – Über 700.000 ISP-IPs.
Mobile Proxys – Über 7 Millionen mobile IPs.

Führen Sie die folgenden Schritte aus, um zu erfahren, wie Sie die Proxys von Bright Data mit HttpClient in C# verwenden können.

Wenn Sie bereits ein Konto haben, melden Sie sich bei Bright Data an. Wenn nicht, erstellen Sie ein kostenloses Konto. Nach der Anmeldung werden Sie zu Ihrem Benutzer-Dashboard weitergeleitet:

Das Dashboard von Bright Data nach der Anmeldung

Klicken Sie auf die Schaltfläche “Proxy-Produkte anzeigen”, um fortzufahren:

Sie werden auf die Seite “Proxies & Scraping-Infrastruktur” weitergeleitet:

Proxies & Scraping Infrastruktur Hauptseite

Blättern Sie nach unten und suchen Sie die Karte “Proxies für Wohnzwecke”. Klicken Sie auf die Schaltfläche “Loslegen”:

Auf der Seite zur Konfiguration des Proxys für Privatanwender folgen Sie dem Assistenten, um den Dienst an Ihre Bedürfnisse anzupassen. Wenn Sie Fragen haben, können Sie sich an den 24/7-Support wenden:

Anpassung des Dienstes an Ihre Bedürfnisse

Gehen Sie auf die Registerkarte “Zugriffsparameter”, um den Host, den Port, den Benutzernamen und das Passwort Ihres Proxys abzurufen:

Beachten Sie, dass das Feld “Host” den Port enthält.

Nun, da Sie die notwendigen Details haben, erstellen Sie Ihre Proxy-URL und verwenden Sie sie mit dem WebProxy-Objekt in C#:

WebProxy proxy = new WebProxy
{
  Address = new Uri("http://<brightdata_proxy_host>:<brightdata_proxy_port>"),
  Credentials = new NetworkCredential("<brightdata_proxy_username>", "<brightdata_proxy_password>"),
};

Ersetzen Sie die Platzhalter durch die Proxy-Informationen von Bright Data.

Schalten Sie die Einstellung “Aktiver Proxy” um, befolgen Sie die restlichen Anweisungen, und schon sind Sie fertig!

Verwenden Sie den folgenden C#-Codeausschnitt, um den Proxy von Bright Data in HttpClient zu integrieren:

using System.Net;

class Program
{
  static async Task Main()
  {
    // initialize a new proxy object
    WebProxy proxy = new WebProxy
    {
      // TODO: replace the placeholders with your Bright Data's proxy info
      Address = new Uri("http://<brightdata_proxy_host>:<brightdata_proxy_port>"),
      Credentials = new NetworkCredential("<brightdata_proxy_username>", "<brightdata_proxy_password>"),
    };

    // define an HTTP client handler with the given proxy
    HttpClientHandler handler = new HttpClientHandler
    {
      Proxy = proxy,
    };

    // disable SSL verification
    handler.ClientCertificateOptions = ClientCertificateOption.Manual;
    handler.ServerCertificateCustomValidationCallback = (httpRequestMessage, cert, cetChain, policyErrors) =>
    {
      return true;
    };

    // initialize an HttpClient instance with proxy integration
    using HttpClient client = new HttpClient(handler);

    // the target URL
    string url = "https://httpbin.org/ip";

    // send an async GET request to the endpoint
    HttpResponseMessage response = await client.GetAsync(url);

    // read the response content as a string
    string responseBody = await response.Content.ReadAsStringAsync();

    // print the response to the console
    Console.WriteLine(responseBody);
  }
}

Jedes Mal, wenn Sie das obige Skript ausführen, wird eine andere Exit-IP angezeigt.

HttpClient-Proxy-Rotation war noch nie so einfach wie mit den automatisch rotierenden Proxys von Bright Data!

Schlussfolgerung

In diesem Tutorial zur Proxy-Integration haben Sie gelernt, warum die Verwendung von Proxys wichtig ist und wie man sie mit HttpClient in C# integriert. Sie haben entdeckt, wie einfach es ist, einen Proxy in HttpClient, der Standard-HTTP-Client-Bibliothek in .NET, einzurichten.

Durch diesen Leitfaden haben Sie auch verstanden, warum es riskant ist, sich auf kostenlose Proxydienste zu verlassen. Stattdessen müssen Sie zuverlässige Proxys von einem seriösen Proxy-Anbieter verwenden. Und wenn es um den besten rotierenden Proxy-Anbieter auf dem Markt geht, suchen Sie nicht weiter als Bright Data.

Erstellen Sie ein Konto und testen Sie unsere Proxys noch heute kostenlos!

Gratis testen

Starte mit Google

Keine Kreditkarte erforderlich

Festlegen eines Proxys mit HttpClient in .NET mit C#