Guide pour l'utilisation d'un proxy avec HttpClient

A la fin de ce guide d’intégration du proxy HttpClient C#, vous saurez :

Qu’est-ce que HttpClient et quel est son rôle dans l’exécution de requêtes HTTP en .NET ?
Pourquoi utiliser un proxy en C#
Comment mettre en place un proxy dans HttpClient
Comment gérer l’authentification par proxy, les erreurs de certificat SSL et la rotation d’IP avec HttpClient.

Plongeons dans l’aventure !

Qu’est-ce que HttpClient en .NET ?

HttpClient est une classe permettant d’effectuer des requêtes HTTP et de recevoir des réponses HTTP dans .NET. Elle fait partie de l’espace de noms System.Net.Http, qui représente le client HTTP par défaut dans .NET et, par conséquent, dans C#.

HttpClient prend en charge :

Toutes les méthodes HTTP, y compris GET, POST, PUT, PATCH et DELETE
Communication asynchrone
En-têtes et personnalisation des cookies
Personnalisation du corps de la demande
Intégration du proxy

Ces caractéristiques, ainsi que sa prise en charge officielle dans la bibliothèque standard .NET, font de HttpClient un choix populaire pour les requêtes HTTP en C#.

Pourquoi faut-il définir un proxy en C# HttpClient ?

Lorsque vous travaillez dans le domaine du web scraping, de la collecte de données ou d’autres tâches liées à l’internet, il est essentiel de protéger votre identité en ligne. L’un des moyens d’y parvenir est d’acheminer votre trafic par l’intermédiaire d’un serveur proxy.

Un serveur proxy agit comme un intermédiaire entre vous et le site de destination, offrant ces avantages à HttpClient :

IP et localisation cachées: Les serveurs de destination voient l’IP du proxy, pas la vôtre.
Confidentialité accrue: Les proxys ajoutent une couche de confidentialité en masquant votre identité réelle et en rendant votre traçage plus difficile.
Éviter les interdictions d’IP: Les proxys vous aident à contourner les limiteurs de débit, ce qui est fondamental dans le web scraping avec C#.
Contourner les restrictions géographiques: Vous pouvez utiliser des serveurs proxy situés dans des régions spécifiques pour accéder à des contenus soumis à des restrictions géographiques depuis votre domicile.

Ainsi, l’utilisation de proxies dans HttpClient augmente non seulement votre sécurité en ligne, mais aussi la fiabilité de vos tâches de scraping.

Mettre en place un proxy avec HttpClient en C# : Guide étape par étape

Suivez les étapes ci-dessous pour apprendre à intégrer un proxy dans HttpClient en .NET à l’aide de C#.

Conditions préalables

Avant de commencer, assurez-vous que vous remplissez les conditions préalables suivantes :

UN IDE C#: Vous pouvez utiliser Visual Studio ou Visual Studio Code. Dans ce guide, nous utiliserons Visual Studio Code avec l’extension C#.
.NET 8+ installé localement: Vous avez besoin de la dernière version de .NET ou de toute version LTS supérieure ou égale à .NET 8. Ce tutoriel utilisera .NET 9.

Si vous ne disposez pas des outils nécessaires, téléchargez-les en utilisant le lien ci-dessus et suivez l’assistant d’installation.

Étape 1 : Mise en place du projet

Créez un nouveau dossier pour votre projet .NET et accédez-y dans le terminal à l’aide des commandes suivantes :

mkdir httpclient-proxy
cd httpclient-proxy

Ensuite, initialiser une nouvelle application Console .NET à l’intérieur de celle-ci :

dotnet run console

Le résultat devrait être :

The template "Console App" was created successfully.

Maintenant, ouvrez le dossier du projet dans votre IDE :

Vous devriez voir les fichiers générés par le modèle, Program.cs étant le plus important. Actuellement, il contient un simple script “Hello, World !”. À la fin de cette section, il s’agira d’un script d’intégration du proxy HttpClient en C#.

Pour vous assurer que tout fonctionne comme prévu, essayez de lancer l’application C# avec :

dotnet run

Le résultat devrait être :

Hello, World!

C’est génial ! Vous avez maintenant un projet C# fonctionnel dans Visual Studio Code.

Étape 2 : Configurer HttpClient

Ajoutez les lignes de code suivantes à Program.cs pour envoyer une requête à l’aide de HttpClient:

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);
  }
}

L’extrait initialise une instance HttpClient et utilise sa méthode GetAsync() pour se connecter au point d’arrivée /ip GET du projet HTTPBin.io. Cette API renvoie l’adresse IP de l’appelant, ce qui en fait une cible parfaite pour vérifier si l’intégration du proxy fonctionne comme prévu. La raison ? Une fois que vous avez intégré un proxy dans HttpClient, l’adresse IP renvoyée par le point de terminaison /ip doit être différente de votre adresse IP d’origine.

Si vous exécutez le script, la sortie devrait ressembler à quelque chose comme :

{
  "origin": "55.17.80.196"
}

L’adresse IP contenue dans l’origine représente votre IP de sortie.

C’est incroyable ! Il est temps d’obtenir une URL de proxy valide.

Étape 3 : Récupérer un proxy

Pour intégrer un proxy dans HttpClient, vous devez d’abord avoir accès à un serveur proxy.

De nombreux portails en ligne proposent des URL de proxy gratuits, mais soyez prudents : l’exploitation d’une infrastructure de proxy est coûteuse. Si un service propose des proxys gratuits, réfléchissez à son modèle économique. Souvent, ils se livrent au vol de données ou à d’autres pratiques douteuses.

C’est pourquoi il est préférable de n’utiliser les proxys gratuits qu’à des fins d’apprentissage et de les éviter pour une utilisation en production !

Si vous avez besoin de proxies fiables, pensez à des fournisseurs réputés qui proposent des essais gratuits ou des plans gratuits limités. Par exemple, vous pouvez essayer nos proxys gratuits.

L’URL d’un proxy typique se présente comme suit :

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

Où ?

protocole spécifie le type de proxy (par exemple, http, https, socks5, etc.)
host: Le domaine ou l’adresse IP du serveur proxy
port: Le numéro de port par lequel le trafic est acheminé

Dans cet exemple, nous supposerons que l’URL du proxy est :

http://66.29.154.103:3128

Enregistrez cela dans une variable du fichier Program.cs :

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

Il est temps de voir comment utiliser un proxy avec HttpClient!

Étape 4 : Intégration du proxy

HttpClient vous permet de spécifier un proxy par le biais de la classe HttpClientHandler. Celle-ci permet un contrôle de bas niveau sur les requêtes HTTP envoyées par une instance de HttpClient.

En particulier, HttpClientHandler possède une propriété Proxy qui accepte un objet WebProxy contenant les paramètres du serveur proxy :

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

Passez ensuite le proxy à une instance de HttpClientHandler:

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

Enfin, nous passons HttpClientHandler au constructeur de HttpClient:

using HttpClient client = new HttpClient(handler);

Merveilleux ! L’intégration du proxy HttpClient C# est terminée.

Étape 5 : Assembler le tout

Votre script final d’intégration du proxy HttpClient doit contenir :

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);
  }
}

Exécuter le script :

dotnet run

Le résultat devrait être :

{
  "origin": "66.29.154.103"
}

Notez que l’attribut origin dans la réponse de l’extrémité /ip affiche l’adresse IP du serveur proxy. Cela confirme que votre véritable adresse IP a été cachée avec succès derrière le proxy.

Avertissement: Les serveurs proxy gratuits sont généralement éphémères et peu fiables. Au moment où vous lirez ce guide, le proxy choisi ne fonctionnera plus. Pour tester le code, remplacez proxyUrl par une URL de proxy valide et fonctionnelle avant d’exécuter le script.

Cas d’utilisation avancés pour l’intégration du proxy HttpClient

Vous venez d’apprendre les bases de l’intégration de proxy avec HttpClient en C#, mais il existe d’autres scénarios plus avancés à prendre en compte.

Authentification par proxy

Les proxys Premium sont protégés par une authentification afin de restreindre l’accès aux utilisateurs autorisés. En particulier, l’URL d’un proxy authentifié suit ce format :

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

Où le nom d'utilisateur et le mot de passe sont les données d’identification utilisées pour l’authentification.

Dans HttpClient, l’authentification par proxy est gérée à l’aide de la propriété Credentials de WebProxy. Cette propriété accepte un objet NetworkCredential comme suit :

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

Extrait et de l’URL de votre proxy authentifié et remplacez-les dans le code ci-dessus.

Ainsi, le code pour l’intégration du proxy authentifié devient :

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);
  }
}

Éviter les problèmes liés aux certificats SSL

Lors de la mise en place d’un proxy dans HttpClient, vos requêtes peuvent échouer en raison de l’erreur de vérification du certificat SSL ci-dessous :

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

Cela se produit généralement lorsque le proxy utilise un certificat SSL auto-signé.

Si vous faites confiance à votre serveur proxy – et uniquement dans ce cas – vous pouvez désactiver la vérification SSL pour contourner ce problème en suivant l’approche suivante :

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

using HttpClient client = new HttpClient(handler);

L’extrait ci-dessus remplace le comportement de validation du certificat par défaut par un rappel personnalisé qui renvoie toujours la valeur "true".

Remarque: la désactivation de la vérification SSL rend votre connexion vulnérable aux attaques MITM (Man-in-the-Middle). N’utilisez cette approche que si vous faites entièrement confiance à votre proxy et que vous êtes conscient des risques de sécurité.

Mise en œuvre de la rotation des mandataires

Si vous utilisez le même serveur proxy à plusieurs reprises, le site cible peut finir par bloquer son adresse IP. Pour éviter cela, vous pouvez alterner vos serveurs proxy pour chaque requête, de sorte que vos requêtes utilisent un serveur proxy différent à chaque fois.

Pour mettre en œuvre la rotation du proxy, suivez la procédure suivante

Remplir une liste avec plusieurs URL de proxy
Sélection aléatoire d’une URL de proxy avant chaque requête
Définir l’URL du proxy choisi dans HttpClient

L’algorithme ci-dessus se traduit par l’extrait suivant :

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];
  }
}

Les principaux inconvénients de cette approche sont les suivants :

Il s’agit d’un code passe-partout
Elle nécessite l’accès à un pool de serveurs proxy fiables, ce qui a généralement un coût

Heureusement, il existe une solution plus efficace pour faire pivoter une adresse IP en C#!

Bright Data fournit des proxys rotatifs qui alternent automatiquement les adresses IP de sortie, éliminant ainsi la nécessité d’une rotation manuelle des proxys. L’entreprise se targue d’avoir environ 100 millions d’adresses IP, d’être disponible dans 195 pays, d’avoir un temps de disponibilité du réseau exceptionnel et de garantir un taux de réussite de 99,9 %.

Dans le prochain chapitre, vous apprendrez à utiliser les proxys rotatifs de Bright Data dans HttpClient.

Utiliser un proxy de données Bright dans HttpClient

Bright Data exploite l’un des plus grands serveurs proxy au monde, au service de sociétés Fortune 500 et de plus de 20 000 clients. Ce réseau mondial de serveurs mandataires comprend :

Proxies de centres de données – Plus de 770 000 IP de centres de données.
Proxies résidentiels – Plus de 72 millions d’adresses IP résidentielles dans plus de 195 pays.
Proxies ISP – Plus de 700 000 IP ISP.
Proxies mobiles – Plus de 7 millions d’IP mobiles.

Suivez les étapes ci-dessous pour apprendre à utiliser les proxys résidentiels de Bright Data avec HttpClient en C#.

Si vous avez déjà un compte, connectez-vous à Bright Data. Sinon, créez un compte gratuitement. Une fois connecté, vous serez dirigé vers votre tableau de bord :

Tableau de bord de Bright Data après connexion

Cliquez sur le bouton “Voir les produits proxy” pour continuer :

En cliquant sur "Voir les produits proxy

Vous serez redirigé vers la page “Proxies & Scraping Infrastructure” :

Page principale de Proxies & Scraping Infrastructure

Faites défiler la page et trouvez la carte “Procurations résidentielles”. Cliquez sur le bouton “Démarrer” :

Sur la page de configuration du proxy résidentiel, suivez l’assistant pour personnaliser le service en fonction de vos besoins. Si vous avez des questions, n’hésitez pas à contacter le service d’assistance 24/7 :

Personnalisation du service en fonction de vos besoins

Allez dans l’onglet “Paramètres d’accès” pour récupérer l’hôte, le port, le nom d’utilisateur et le mot de passe de votre proxy :

Les paramètres d'accès à votre nouvelle zone

Notez que le champ “Host” inclut le port.

Maintenant que vous disposez des informations nécessaires, créez votre URL proxy et utilisez-la avec l’objet WebProxy en C# :

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

Remplacez les par les informations de proxy de Bright Data.

Activez le paramètre “Proxy actif”, suivez les instructions restantes et vous êtes prêt !

Utilisez l’extrait de code C# suivant pour intégrer le proxy de Bright Data à HttpClient :

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);
  }
}

Chaque fois que vous exécuterez le script ci-dessus, vous verrez une IP de sortie différente.

La rotation de proxy HttpClient n’a jamais été aussi facile avec les proxys auto-rotatifs de Bright Data !

Conclusion

Dans ce tutoriel sur l’intégration de proxy, vous avez appris pourquoi il est important d’utiliser des proxys et comment les intégrer à HttpClient en C#. Vous avez découvert à quel point il est facile de configurer un proxy dans HttpClient, la bibliothèque client HTTP par défaut de .NET.

Grâce à ce guide, vous avez également compris pourquoi il est risqué de se fier à des services de proxy gratuits. Au lieu de cela, vous devez utiliser des proxies fiables provenant d’un fournisseur de proxy réputé. Et lorsqu’il s’agit du meilleur fournisseur de proxy rotatif sur le marché, ne cherchez pas plus loin que Bright Data.

Créez un compte et commencez à tester nos proxies gratuitement dès aujourd’hui !

Essai gratuit

S’inscrire avec Google

Aucune carte de crédit requise

Comment définir un proxy à l’aide de HttpClient en .NET avec C#

Qu’est-ce que HttpClient en .NET ?

Pourquoi faut-il définir un proxy en C# HttpClient ?

Mettre en place un proxy avec HttpClient en C# : Guide étape par étape

Conditions préalables

Étape 1 : Mise en place du projet

Étape 2 : Configurer HttpClient

Étape 3 : Récupérer un proxy

Étape 4 : Intégration du proxy

Étape 5 : Assembler le tout

Cas d’utilisation avancés pour l’intégration du proxy HttpClient

Authentification par proxy

Éviter les problèmes liés aux certificats SSL

Mise en œuvre de la rotation des mandataires

Utiliser un proxy de données Bright dans HttpClient

Conclusion

Plus de 150M de proxies résidentiels

Vous pourriez aussi être intéressé par

Qu’est-ce qu’un “embedded” dans l’apprentissage automatique ?

Qu’est-ce que l’apprentissage Zero-Shot ?

Guide de l’analyse de données avec Python en 2025