Windows Dev Center

Verwenden von System.Net.Http.HttpClient-Handlern (Windows Store-Apps mit C#/VB und XAML)

Verwenden Sie die System.Net.Http.HttpClientHandler-Klasse mit der System.Net.Http.HttpClient-Klasse im System.Net.Http-Namespace, um eine GET-Anforderung an einen Webdienst zu senden und die Antwort abzurufen.

Hinweis  Die Namespaces System.Net.Http und System.Net.Http.Headers sind in zukünftigen Windows-Versionen möglicherweise nicht mehr zur Verwendung in Windows Store-Apps verfügbar. Verwenden Sie ab Windows 8.1 und Windows Server 2012 R2 stattdessen Windows.Web.Http.HttpClient im Windows.Web.Http-Namespace und den zugehörigen Namespaces Windows.Web.Http.Headers und Windows.Web.Http.Filters für Windows Store-Apps.

Klassen im System.Net.Http-Namespace stellen eine Programmierschnittstelle für moderne HTTP-Apps bereit. Der System.Net.Http-Namespace und der dazugehörige System.Net.Http.Headers-Namespace stellen HTTP-Clientkomponenten bereit, mit denen Benutzer moderne Webdienste über HTTP nutzen können.

Die System.Net.Http.HttpClient-Klasse wird zum Senden und Empfangen grundlegender Anforderungen über HTTP verwendet. Sie stellt eine Basisklasse zum Versenden von HTTP-Anforderungen und Empfangen von HTTP-Antworten aus einer von der URI bestimmten Ressource bereit. Mit dieser Klasse kann eine GET-, PUT-, POST-, DELETE- oder andere Anforderung an den Webdienst gesendet werden. Jede dieser Anforderungen wird als asynchrone Operation gesendet.

Die System.Net.Http.HttpClientHandler-Klasse ist der standardmäßige Meldungshandler für System.Net.Http.HttpClient. Dank der System.Net.Http.HttpClientHandler-Klasse und der davon abgeleiteten Klassen können Entwickler eine Reihe von Optionen für eine HTTP-Anforderung konfigurieren. Diese Optionen reichen von Proxys bis hin zur Authentifizierung.

Die System.Net.Http.HttpResponseMessage-Klasse stellt eine HTTP-Antwortnachricht dar, die von einer HTTP-Anforderung empfangen wurde. HTTP-Nachrichten werden von IETF in RFC 2616 definiert.

Die System.Net.Http.HttpContent-Klasse ist eine Basisklasse, die einen HTTP-Entitätskörper und Inhaltsheader darstellt. In diesem Fall wird System.Net.Http.HttpContent verwendet, um die HTTP-Antwort darzustellen.

Wissenswertes

Technologien

Voraussetzungen

Die folgenden Beispiele in diesem Abschnitt sind in C# mit .NET Framework 4.5 geschrieben. Zum Verständnis dieses Beispiels ist ein grundlegendes Verständnis der HTTP-Anforderungen gemäß RFC 2616 von Vorteil.

Informationen zum Ausführen von HTTP-Anforderungen in einer Windows-Runtime-App mit C#/VB und XAML finden Sie unter So wird's gemacht: Herstellen einer Verbindung mit einem HTTP-Server mithilfe von "Windows.Web.Http.HttpClient". Informationen zum Ausführen von HTTP-Anforderungen in einer Windows-Runtime-App mit C++ und XAML finden Sie unter So wird's gemacht: Herstellen einer Verbindung mit einem HTTP-Server mithilfe von "Windows.Web.Http.HttpClient" sowie unter So wird's gemacht: Herstellen einer Verbindung mit erweiterten XML-HTTP-Anforderungen und "IXMLHTTPRequest2".

Informationen zum Senden von HTTP-Anforderungen in einer Windows-Runtime-App mit JavaScript und HTML finden Sie unter Herstellen einer Verbindung zu Webdiensten (HTML).

Anweisungen

Schritt 1: Erstellen eines neuen Projekts

  1. Öffnen Sie Microsoft Visual Studio 2013, und wählen Sie Neues Projekt im Menü Datei aus.
  2. Wählen Sie aus der Liste der Vorlagen Visual C# aus.
  3. Wählen Sie unterhalb des Abschnitts Store-Apps aus.
  4. Wählen Sie unterhalb des Abschnitts die Option Windows-Apps und anschließend Leere Anwendung aus.
  5. Geben Sie für die App den Namen HttpClientHandlerSample ein, und klicken Sie auf OK.

Schritt 2: Einrichten der Funktionen zur Aktivierung des Netzwerkzugriffs

Sie müssen die Netzwerkfunktionen für Ihre App einrichten, um den Zugriff auf eine private Homepage oder ein Firmennetzwerk sowie auf das Internet zu ermöglichen. Für diese App müssen Sie Netzwerkfunktionen einrichten, da der Client eine Verbindung zu Webservices herstellt.

Für eine App, die System.Net.Http.HttpClient oder System.Net.Http.HttpClientHandler verwendet, um eine Verbindung mit einem Webdienst oder mit einem anderen Computer herzustellen, müssen Netzwerkfunktionen festgelegt werden. Wenn die App als Client eine Verbindung mit Webdiensten im Internet herstellen können muss, ist die Funktion Internet (Client) erforderlich. Wenn die App als Client eine Verbindung mit Webdiensten in einem Heim- oder Firmennetzwerk herstellen können muss, ist die Funktion Private Netzwerke (Client und Server) erforderlich.

Wenn der Webdienst auf dem gleichen Computer ausgeführt wird wie die App, ist hierfür ein Loopbackzugriff erforderlich. Apps, die in Microsoft Visual Studio 2012 entwickelt wurden, werden automatisch so registriert, dass sie von den Loopbackeinschränkungen ausgenommen werden. Weitere Informationen finden Sie unter Aktivieren von Loopback und Debuggen der Netzwerkisolation.

Weitere Informationen zum Netzwerkzugriff finden Sie unter Konfigurieren von Netzwerkisolationsfunktionen.

Die im Folgenden aufgeführten Schritte sind für dieses Beispiel nicht nötig, wenn der Webservice sich auf dem lokalen Computer befindet. Die Schritte müssen durchgeführt werden, um Netzwerkfunktionen für die App einzurichten, wenn sie auf einen Webservice im Internet oder auf ein privates oder Firmennetzwerk zugreift.

  1. Öffnen Sie die Datei package.appxmanifest in Visual Studio 2012.
  2. Wählen Sie die Registerkarte Capabilities (Funktionen) aus.
  3. Wählen Sie die Funktionen Internet (Client) und Private Netzwerke (Client und Server) aus.
  4. Speichern und schließen Sie die Manifestdatei.

Schritt 3: Hinzufügen der XAML-UI

  • In diesem Abschnitt definieren wir das App-Layout in XAML, um die Größe und die Position der einzelnen Objekte in der App festzulegen. Wir stellen die Benutzeroberfläche für die App fertig, indem wir Steuerelemente und Inhalt zum Anzeigen der Daten hinzufügen.

    In diesem Beispiel werden einfache XAML-UI-Elemente verwendet, wie z. B. die folgenden:

    • Ein horizontales StackPanel, das ein TextBlock für eine Bezeichnung, ein TextBox für die Eingabe der URI-Adresse und ein Button zum Starten der asynchronen Anforderung enthält.
    • Ein horizontales StackPanel, das ein TextBlock für eine Bezeichnung und eine TextBox für den aktuellen Status enthält. Hier werden die Status- und Fehlernachrichten angezeigt.

    Ein Grid, in dem die Ausgabe aus dem Webservice angezeigt wird. In diesem Beispiel wird das Ergebnis des HTTP GET-Vorgangs mit einem Element vom Typ WebView angezeigt, um das HTML-Markup zu rendern.

    Öffnen Sie den Ordner cs. Öffnen Sie die vorhandene Datei blankPage.html, und benennen Sie sie in MainPage.xaml um. Fügen Sie die folgenden UI-Elemente zu dieser Datei hinzu.

    
    <Page
        x:Class="HttpClientHandlerSample.BlankPage"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:local="using:HttpClientHandlerSample"
        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>
                    <WebView x:Name="OutputView" MinWidth="300"  MinHeight="300" Margin="15,15,15,15"  />
                </Grid>    
            </StackPanel>
         </Grid>
    </Page>
    
    
    

Schritt 4: Erstellen des HttpClientHandler-Elements, Senden der GET-Anforderung und Abrufen der Antwort

Der unten gezeigte Code erstellt zuerst ein System.Net.Http.HttpClientHandler-Objekt. Für das Objekt wird eine Eigenschaft festgelegt, und mithilfe von System.Net.Http.HttpClientHandler wird ein System.Net.Http.HttpClient-Objekt erstellt.

  1. Erstellen Sie zuerst das System.Net.Http.HttpClientHandler-Objekt. Legen Sie die AllowAutoRedirect-Eigenschaft auf false fest. Dies ist ein Beispiel dafür, wie Sie mit System.Net.Http.HttpClientHandler-Eigenschaften Optionen für die HTTP-Anforderung festlegen können.

    Die AllowAutoRedirect-Eigenschaft gibt an, ob Anforderungen des System.Net.Http.HttpClientHandler-Objekts Umleitungsantworten folgen sollen. Der Standardwert für diese Eigenschaft ist true. Wenn diese Eigenschaft auf false festgelegt ist, werden Webdienstanforderungen zum Umleiten der Anforderung nicht befolgt.

    Erstellen Sie dann mithilfe des System.Net.Http.HttpClientHandler-Objekts das System.Net.Http.HttpClient-Objekt. Außerdem legen wir zwei Eigenschaften im System.Net.Http.HttpClient-Objekt fest. Die Standardgröße der HttpClient.MaxResponseContentBufferSize-Eigenschaft entspricht dem Maximalwert für eine ganze Zahl. Um den Umfang der Daten zu begrenzen, die die App als Antwort vom Webdienst akzeptiert, wird diese Eigenschaft hier auf einen kleineren Wert festgelegt.

    Das System.Net.Http.HttpClient-Objekt sendet standardmäßig in der HTTP-Anforderung keinen Benutzer-Agent-Header an den Webdienst. Einige HTTP-Server, darunter einige von Microsoft, verlangen aber, dass ein Benutzer-Agent-Header in die HTTP-Anforderungen vom Client eingefügt wird. Diese Server geben andernfalls einen Fehler zurück. Der Benutzer-Agent-Header wird mit der HttpClient.DefaultRequestHeaders-Eigenschaft hinzugefügt, um solche Fehler zu vermeiden.

    Öffnen Sie den Ordner cs. Öffnen Sie die Datei MainPage.cs, und fügen Sie ihr den folgenden Code hinzu.

    
        private HttpClient httpClient;
        private HttpClientHandler handler;
    
        public BlankPage()
        {
            this.InitializeComponent();
            handler = new HttpClientHandler();
            handler.AllowAutoRedirect=false; 
    
            httpClient = new HttpClient(handler);
    
            // Limit the max buffer size for the response so we don't get overwhelmed
            httpClient.MaxResponseContentBufferSize = 256000;
            // Add a user-agent header
            httpClient.DefaultRequestHeaders.Add("user-agent", "Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.2; WOW64; Trident/6.0)");
        }
    
    
    
  2. Senden Sie die GET-Anforderung, und rufen Sie die Antwort ab.

    Die meiste Arbeit wird im Klickhandler für das Button-Element "Start" ausgeführt. Durch einen Klick auf diese Schaltfläche aktualisieren Sie den Text in den UI-Elementen StatusText und OutputView. Anschließend verwenden Sie die Eingabe-URI-Adresse zum Senden der HTTP GET-Anforderung und warten die Antwort ab. Wenn ein Fehler oder eine Ausnahme auftritt, wird das Ergebnis im UI-Element StatusText angezeigt. Wenn kein Fehler auftritt, wird die Antwort des Webdiensts im OutputView-Benutzeroberflächenelement angezeigt.

    Mit dem await-Schlüsselwort in C# und Visual Basic ähnelt der Code zum Senden der GET-Anforderung und zum synchronen Abrufen dem Code, der zum synchronen Abschluss dieser Operation verwendet wird. Das await-Schlüsselwort kann nur verwendet werden, wenn die Methode als async definiert ist.

    Die Methode HttpResponseMessage.EnsureSuccessStatusCode löst eine Ausnahme aus, wenn der Webserver einen HTTP-Fehlerstatuscode zurückgegeben hat. Verwenden Sie für alle Ausnahmen einen Try-Catch-Block, und geben Sie die Ausnahmemeldung im StatusText-Benutzeroberflächenelement aus, wenn ein Fehler auftritt. Geben Sie im Try-Block den Status und die Antwort aus, die vom Webservice zurückgegeben wurden.

    Die HttpResponseMessage.Content-Eigenschaft stellt den Inhalt der HTTP-Antwort dar. Die HttpContent.ReadAsStringAsync-Methode schreibt den HTTP-Inhalt als asynchrone Operation in eine Zeichenfolge.

    
            private async void Start_Click(object sender, RoutedEventArgs e)
            {
                try
                {
                    string responseBodyAsText;
                    OutputView.NavigateToString("");
                    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();
                    OutputView.NavigateToString(responseBodyAsText);
                }
                catch (HttpRequestException hre)
                {
                    StatusText.Text = hre.ToString();
                }
                catch (Exception ex)
                {
                    // For debugging
                    StatusText.Text = ex.ToString();
                }
            }
    
    
    
    

Anmerkungen

In diesem Thema haben wir uns mit der Verwendung von System.Net.Http.HttpClientHandler in Verbindung mit der System.Net.Http.HttpClient-Klasse beschäftigt, um eine GET-Anforderung an einen Webdienst zu senden und die Antwort mithilfe der Klassen System.Net.Http.HttpResponseMessage und System.Net.Http.HttpContent abzurufen. Dank System.Net.Http.HttpClientHandler konnte die App Optionen für die HTTP-Anforderung festlegen.

Es stehen mehrere HTTP-Meldungshandler zur Verfügung, die mit der System.Net.Http.HttpClient-Klasse verwendet werden können.

Beispiel für HttpClientHandler


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 HttpClientHandlerSample
{
    /// <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;
        private HttpClientHandler handler;

        public BlankPage()
        {
            this.InitializeComponent();
            handler = new HttpClientHandler();
            handler.AllowAutoRedirect=false; 

            httpClient = new HttpClient(handler);
            // Limit the max buffer size for the response so we don't get overwhelmed

            httpClient.MaxResponseContentBufferSize = 256000;
            // Add a user-agent header
            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.NavigateToString("");
                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();
                OutputView.NavigateToString(responseBodyAsText);
            }
            catch (HttpRequestException hre)
            {
                StatusText.Text = hre.ToString();
            }
            catch (Exception ex)
            {
                // For debugging
                StatusText.Text = ex.ToString();
            }
        }
    }
}


Verwandte Themen

Weitere Ressourcen
Herstellen von Verbindungen mit Webdiensten
So wird's gemacht: Konfigurieren von Netzwerkfunktionen
So wird's gemacht: Herstellen einer Verbindung mit "System.Net.Http.HttpClient"
Aktivieren von Loopback und Debuggen der Netzwerkisolation.
Sichern von System.Net.Http.HttpClient-Verbindungen
Problembehandlung und Debuggen von Netzwerkverbindungen
Referenz
System.Net.Http
System.Net.Http.Headers
Windows.Web.Http
Windows.Web.Http.Filters
Windows.Web.Http.Headers
Beispiele
Beispiel für HttpClient

 

 

Anzeigen:
© 2015 Microsoft