Comment se connecter à l’aide de System.Net.Http.HttpClient (applications du Windows Store en C#/VB et XAML)

Applies to Windows only

Utilisez la classe HttpClient dans l’espace de noms System.Net.Http pour envoyer une requête GET à un service Web et récupérer la réponse.

Remarque  Les espaces de noms System.Net.Http et System.Net.Http.Headers peuvent ne pas être disponibles dans les versions ultérieures de Windows pour une utilisation par les applications du Windows Store. À compter de Windows 8.1 et de Windows Server 2012 R2, vous devez plutôt utiliser Windows.Web.Http.HttpClient dans l’espace de noms Windows.Web.Http et les espaces de noms Windows.Web.Http.Headers et Windows.Web.Http.Filters associés pour les applications Windows Runtime.

Les classes incluses dans l’espace de noms System.Net.Http offrent une interface de programmation pour les applications HTTP modernes. L’espace de noms System.Net.Http et son espace de noms associé fournissent des composants clients HTTP qui permettent aux utilisateurs d’exploiter des services Web modernes sur HTTP.

La classe System.Net.Http.HttpClient sert à envoyer et recevoir des requêtes de base sur HTTP. Elle constitue une classe de départ pour l’envoi de requêtes HTTP et la réception de réponses HTTP depuis une source identifiée par un URI. Vous pouvez utiliser cette classe pour transmettre une requête GET, PUT, POST et DELETE, ou toute autre requête, à un service Web. Chacune de ces requêtes est envoyée dans le cadre d’une opération asynchrone.

La classe System.Net.Http.HttpResponseMessage représente un message de réponse HTTP reçu d’une requête HTTP. Les messages HTTP sont définis par la norme RFC 2616 de l’IETF (Internet Engineering Task Force).

La classe System.Net.Http.HttpContent est une classe élémentaire qui représente un corps d’entité HTTP et des en-têtes de contenu. Dans ce cas, la classe System.Net.Http.Http.Content est utilisée pour identifier la réponse HTTP.

Prérequis

Les exemples qui suivent dans cette rubrique sont présentés en langage C# avec .NET Framework 4.5. Une connaissance de base des requêtes HTTP telles qu’elles sont détaillées dans la norme RFC 2616 est utile pour comprendre cet exemple.

Pour effectuer des requêtes HTTP dans une application Windows Runtime en C#/VB et XAML, voir Comment se connecter à un serveur HTTP à l’aide de Windows.Web.Http.HttpClient. Pour effectuer des requêtes HTTP dans une application Windows Runtime en C++ et XAML, voir Comment se connecter à un serveur HTTP à l’aide de Windows.Web.Http.HttpClient et Comment se connecter à l’aide de XML HTTP Extended Request et IXMLHttpRequest2.

Pour effectuer des requêtes HTTP dans une application Windows Runtime en JavaScript et HTML, voir Connexion aux services Web (HTML).

Créer un projet

  1. Ouvrez Microsoft Visual Studio 2013 et sélectionnez Nouveau projet dans le menu Fichier.
  2. Dans la liste des modèles, choisissez Visual C#.
  3. Sous la section, choisissez Store apps.
  4. Sous la section, sélectionnez Windows apps, puis Application vide.
  5. Nommez l’application HttpClientBasic et cliquez sur OK.

Définir les fonctionnalités pour activer l’accès réseau

Vous devez définir les fonctionnalités réseau de votre application pour autoriser l’accès à un réseau domestique privé, un réseau professionnel ou à Internet. Pour cette application, vous devez normalement activer les fonctionnalités réseau puisque le client est connecté aux services Web.

Pour qu’une application utilisant la classe System.Net.Http.HttpClient puisse se connecter à un service Web sur un autre ordinateur, il faut que les capacités réseau soient définies pour cette application. Si l’application doit pouvoir se connecter en qualité de client à un service Web sur Internet, la fonctionnalité Internet (client) est nécessaire. Si l’application doit être en mesure de se connecter en qualité de client à des services Web sur un réseau domestique privé ou un réseau professionnel, la capacité Réseaux privés (client et serveur) est requise.

Si le service Web est exécuté sur le même ordinateur que l’application, ceci nécessite un accès en boucle. Les applications développées dans Microsoft Visual Studio 2012 seront automatiquement inscrites comme n’étant pas concernées par les restrictions de bouclage. Pour plus d’informations, voir Comment activer le bouclage et déboguer l’isolement réseau.

Pour plus d’informations sur l’accès réseau, voir Comment configurer les fonctionnalités d’isolement réseau.

Les étapes décrites ci-après ne sont pas nécessaires pour cet exemple si le service Web se trouve sur l’ordinateur local. Ces étapes sont utiles pour définir les fonctionnalités réseau de l’application si cette dernière a accès à un service Web sur Internet ou sur un réseau privé ou professionnel.

  1. Utilisez Visual Studio 2012 pour ouvrir le fichier package.appxmanifest.
  2. Sélectionnez l’onglet Capacités.
  3. Sélectionnez les fonctionnalités Internet (client) et Réseaux privés (client et serveur).
  4. Enregistrez et fermez le fichier manifeste.

Ajouter une interface utilisateur XAML

  • Dans cette section, nous définissons la structure des applications dans XAML pour spécifier la taille et la position de chaque objet dans l’application. Nous complétons l’interface utilisateur de l’application en ajoutant des contrôles et du contenu pour afficher les données.

    Cet exemple utilise des éléments d’interface utilisateur XAML qui comprennent les composants suivants :

    • Un objet StackPanel horizontal qui contient un objet TextBlock pour une étiquette, un objet TextBox pour l’adresse URI d’entrée et un objet Button (bouton) utilisé pour lancer la requête asynchrone.
    • Un objet StackPanel horizontal contenant un objet TextBlock pour une étiquette et un objet TextBox pour l’état actuel. C’est à cet emplacement que les messages d’état et d’erreur sont affichés.

    Un élément Grid où les données en sortie reçues du service Web sont affichées. Dans cet exemple, le résultat de l’opération GET HTTP est affiché sous la forme de texte brut contenant le balisage HTML.

    Ouvrez le dossier cs. Ouvrez le fichier blankPage.html existant et renommez le fichier MainPage.xaml. Ajoutez les éléments d’interface utilisateur suivants à ce fichier.

    
    <Page
        x:Class="HttpClientBasic.BlankPage"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:local="using:HttpClientBasic"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        mc:Ignorable="d">
    
        <Grid Background="{StaticResource ApplicationPageBackgroundBrush}">
            <StackPanel Orientation="Vertical">
                <StackPanel Orientation="Horizontal">
                    <TextBlock Text="URI Address:" FontSize="16" Height="20"  Margin="15,0,0,0" />
                    <TextBox x:Name="InputAddress" Text="http://www.contoso.com" FontSize="16" Height="20" Margin="15,0,0,0" />
                    <Button Content="Start" Click="Start_Click" Margin="280,0,0,0" />
                </StackPanel>
                <StackPanel Orientation="Horizontal">
                    <TextBlock Text="Status:" FontSize="16" Height="20" Margin="15,0,0,0" />
                    <TextBox x:Name="StatusText" Text="Idle" FontSize="16" Height="Auto" TextWrapping="Wrap" Margin="15,0,0,0" />
                </StackPanel>
                <Grid 
                    Grid.Column="1" Margin="15,0,0,0">
                    <Grid.RowDefinitions>
                        <RowDefinition Height="Auto" />
                        <RowDefinition Height="*" />
                    </Grid.RowDefinitions>
                    <TextBlock x:Name="OutputView" FontSize="16" Height="Auto" Margin="15,0,0,0" TextWrapping="Wrap" />
                </Grid>    
            </StackPanel>
         </Grid>
    </Page>
    
    
    

Créez l’objet HttpClient, envoyez la requête GET et récupérez la réponse.

Le code ci-dessous crée d’abord un objet System.Net.Http.HttpClient.

  1. Pour commencer, créez l’objet HttpClient. Nous définissons également deux propriétés sur l’objet HttpClient.

    La taille par défaut de la propriété HttpClient.MaxResponseContentBufferSize est la taille maximale pour un entier. Pour limiter le volume de données que l’application accepte en tant que réponse du service Web, nous attribuons à cette propriété une valeur moins élevée.

    Par défaut, aucun en-tête d’agent utilisateur n’est envoyé avec la requête HTTP au service Web par l’objet HttpClient. Certains serveurs HTTP, y compris certains serveurs Web Microsoft, nécessitent qu’un en-tête d’agent utilisateur soit fourni avec la requête HTTP envoyée à partir du client, et renvoient une erreur si aucun en-tête n’est présent. Un en-tête d’agent utilisateur est ajouté à l’aide de la propriété HttpClient.DefaultRequestHeaders afin d’éviter ces erreurs.

    Ouvrez le dossier cs. Ouvrez le fichier MainPage.cs et ajoutez-y le code suivant.

    
        private HttpClient httpClient;
    
        public BlankPage()
        {
            this.InitializeComponent();
            httpClient = new HttpClient();
            // Limit the max buffer size for the response so we don't get overwhelmed
            httpClient.MaxResponseContentBufferSize = 256000;
            httpClient.DefaultRequestHeaders.Add("user-agent", "Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.2; WOW64; Trident/6.0)");
        }
    
    
    
  2. Envoyez la requête GET et extrayez la réponse.

    La plupart des tâches sont réalisées dans le gestionnaire d’événements de clic du bouton (Button) de démarrage. Lorsque vous cliquez sur ce bouton, le texte dans les éléments StatusText et OutputView de l’interface utilisateur sont mis à jour, puis l’adresse URI d’entrée est utilisée pour envoyer la requête HTTP GET et attendre la réponse. Si une erreur ou une exception survient, les résultats s’affichent dans l’élément StatusText de l’interface utilisateur. En l’absence d’erreur, la réponse donnée par le service Web apparaît dans l’élément OutputView de l’interface utilisateur.

    Grâce à l’utilisation du mot clé await dans C# et Visual Basic, le code pour envoyer la requête GET et extraire la réponse de manière asynchrone équivaut au code que nous utiliserions pour mener cette opération de manière synchrone. Vous pouvez utiliser le mot clé await seulement si la méthode est définie avec le mot clé async.

    La méthode HttpResponseMessage.EnsureSuccessStatusCode lève une exception si le serveur Web a renvoyé un code d’état d’erreur HTTP. Utilisez un bloc try/catch pour toutes les exceptions et affichez le message d’exception dans l’élément StatusText de l’interface utilisateur si une erreur se produit. Dans le bloc try, imprimez l’état et la réponse renvoyés par le service Web.

    La propriété HttpResponseMessage.Content désigne le contenu de la réponse HTTP. La méthode HttpContent.ReadAsStringAsync écrit le contenu HTTP dans une chaîne par une opération asynchrone. Nous remplaçons toutes les balises <br> présentes dans le code HTML renvoyé par de nouvelles lignes à des fins d’affichage.

    
            private async void Start_Click(object sender, RoutedEventArgs e)
            {
                try
                {
                    string responseBodyAsText;
                    OutputView.Text = "";
                    StatusText.Text = "Waiting for response ...";
    
                    HttpResponseMessage response = await httpClient.GetAsync(InputAddress.Text);
                    response.EnsureSuccessStatusCode();
    
                    StatusText.Text = response.StatusCode + " " + response.ReasonPhrase + Environment.NewLine;
                    responseBodyAsText = await response.Content.ReadAsStringAsync();
                    responseBodyAsText = responseBodyAsText.Replace("<br>", Environment.NewLine); // Insert new lines
                    OutputView.Text = responseBodyAsText;
                }
                catch (HttpRequestException hre)
                {
                    StatusText.Text = hre.ToString();
                }
                catch (Exception ex)
                {
                    // For debugging
                    StatusText.Text = ex.ToString();
                }
            }
    
    
    
    

    Dans le cas où une application qui utilise la classe HttpClient et les classes associées dans l’espace de noms System.Net.Http essaie de télécharger de grandes quantités de données (50 Mo ou plus), l’application devrait alors transmettre en continu ces téléchargements et éviter de recourir à la mise en mémoire tampon par défaut. Dans le cas du recours à la mise en mémoire tampon par défaut, la consommation de mémoire du client peut devenir très importante et engendrer des baisses de performance non négligeables.

    La classe UriFormatException qui est levée, lorsqu’un URI (Uniform Resource Identifier) est non valide, est détectée par les membres de la classe HttpClient et les classes associées. Cette exception ne peut pas être utilisée dans les applications du Windows Store. Pour intercepter cette exception dans ce cas, écrivez plutôt une instruction catch pour la classe FormatException.

Récapitulatif et étapes suivantes

Dans cette rubrique, nous avons vu comment utiliser la classe System.Net.Http.HttpClient pour envoyer une requête GET à un service Web et récupérer la réponse à l’aide des classes System.Net.Http.HttpResponseMessage et System.Net.Http.HttpContent.

Exemple HttpClientBasic


using System;
using System.Collections.Generic;
using System.IO;
using System.Net.Http;
using Windows.Foundation;
using Windows.Foundation.Collections;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
using Windows.UI.Xaml.Controls.Primitives;
using Windows.UI.Xaml.Data;
using Windows.UI.Xaml.Input;
using Windows.UI.Xaml.Media;
using Windows.UI.Xaml.Navigation;

// The Blank Page item template is documented at http://go.microsoft.com/fwlink/p/?linkid=234238

namespace HttpClientBasic
{
    /// <summary>
    /// An empty page that can be used on its own or navigated to within a Frame.
    /// </summary>
    public sealed partial class BlankPage : Page
    {
        private HttpClient httpClient;

        public BlankPage()
        {
            this.InitializeComponent();
            httpClient = new HttpClient();
            // Limit the max buffer size for the response so we don't get overwhelmed
            httpClient.MaxResponseContentBufferSize = 256000;
            httpClient.DefaultRequestHeaders.Add("user-agent", "Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.2; WOW64; Trident/6.0)");
        }


        /// <summary>
        /// Invoked when this page is about to be displayed in a Frame.
        /// </summary>
        /// <param name="e">Event data that describes how this page was reached.  The Parameter
        /// property is typically used to configure the page.</param>
        protected override void OnNavigatedTo(NavigationEventArgs e)
        {
        }

        private async void Start_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                string responseBodyAsText;
                OutputView.Text = "";
                StatusText.Text = "Waiting for response ...";

                HttpResponseMessage response = await httpClient.GetAsync(InputAddress.Text);
                response.EnsureSuccessStatusCode();

                StatusText.Text = response.StatusCode + " " + response.ReasonPhrase + Environment.NewLine;
                responseBodyAsText = await response.Content.ReadAsStringAsync();
                responseBodyAsText = responseBodyAsText.Replace("<br>", Environment.NewLine); // Insert new lines
                OutputView.Text = responseBodyAsText;
            }
            catch (HttpRequestException hre)
            {
                StatusText.Text = hre.ToString();
            }
            catch (Exception ex)
            {
                // For debugging
                StatusText.Text = ex.ToString();
            }
        }
    }
}


La classe System.Net.Http.HttpClientHandler peut être utilisée avec la classe System.Net.Http.HttpClient pour définir les options relatives à la requête HTTP. Pour plus d’informations, voir Comment utiliser les gestionnaires System.Net.Http.HttpClient.

Rubriques associées

Autres ressources
Connexion aux services Web
Comment configurer les fonctionnalités réseau
Comment se connecter à un serveur HTTP à l’aide de Windows.Web.Http.HttpClient
Comment activer le bouclage et déboguer l’isolement réseau
Comment sécuriser les connexions System.Net.Http.HttpClient
Comment utiliser les gestionnaires System.Net.Http.HttpClient
Référence
System.Net.Http
System.Net.Http.Headers
Windows.Web.Http
Windows.Web.Http.Filters
Windows.Web.Http.Headers
Exemples
Exemple HttpClient

 

 

Afficher:
© 2014 Microsoft