Schnellstart: Herstellen einer Verbindung mit "System.Net.Http.HttpClient" (Windows Store-Apps mit C#/VB und XAML)

Verwenden Sie die HttpClient-Klasse im System.Net.Http-Namespace, um eine GET-Anforderung an einen Webdienst zu senden und eine 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 zugehörige 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.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.Http.Content verwendet, um die HTTP-Antwort darzustellen.

Voraussetzungen

Die folgenden Beispiele in diesem Abschnitt sind in C# mit .NET Framework 4.5 geschrieben. Dazu sind grundlegende Kenntnisse von HTTP-Anforderungen gemäß RFC 2616 erforderlich.

Informationen zum Senden von HTTP-Anforderungen in einer Windows Store-App mit C++ und XAML finden Sie unter Herstellen einer Verbindung mit erweiterten XML-HTTP-Anforderungen und "IXMLHTTPRequest2".

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

Erstellen eines neuen Projekts

  • Öffnen Sie Microsoft Visual Studio 2012, und wählen Sie Neues Projekt im Menü Datei aus. Wählen Sie aus der Liste der Vorlagen Visual C# aus. Wählen Sie in dem Abschnitt "Windows Store-App" und anschließend Leere Anwendung aus. Geben Sie für die App den Namen HttpClientBasic ein, und klicken Sie auf OK.

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 zum Herstellen einer Verbindung mit einem Webdienst auf einem anderen Computer verwendet, müssen Netzwerkfunktionen für die App 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 Webservices in einem Heim- oder Arbeitsplatznetzwerk herstellen 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 Visual Studio 2012 entwickelt wurden, werden automatisch so registriert, dass sie von den Loopbackeinschränkungen ausgenommen werden. Daher sind in diesem speziellen Fall keine Netzwerkfunktionen zum Testen nötig. 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" mit 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.

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-Benutzeroberflächenelemente 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 werden die Ergebnisse des HTTP GET-Vorgangs als unformatierter Text mit HTML-Markup angezeigt.

    Ö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 Benutzeroberflächenelemente zu dieser Datei hinzu.

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

Senden Sie den HttpClient, senden Sie die GET-Anforderung, und rufen Sie die Antwort ab.

Der unten gezeigte Code erstellt zuerst ein System.Net.Http.HttpClient-Objekt.

  1. Erstellen Sie zuerst das HttpClient-Objekt. Außerdem legen wir zwei Eigenschaften im 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 HttpClient-Objekt sendet in der HTTP-Anforderung standardmäßig 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;
    
        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. 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 Benutzeroberflächenelementen 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. Für die Anzeige ersetzen wir alle <br>-Tags im zurückgegebenen HTML-Text durch Zeilenumbrüche.

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

    Wenn eine App mit HttpClient und verwandten Klassen im System.Net.Http-Namespace große Datenmengen (50 MB oder mehr) herunterladen möchten, sollte die App diese Downloads streamen und nicht den Standardpuffer verwenden. Bei Verwendung des Standardpuffers steigt die Speicherauslastung des Clients stark an, was zu erheblichen Leistungseinschränkungen führen kann.

    Die UriFormatException, die ausgelöst wird, wenn von Membern der HttpClient-Klasse und verwandter Klassen ein ungültiger URI ermittelt wird. Diese Ausnahme steht für die Verwendung in Windows Store-Apps nicht zur Verfügung. Um die Ausnahme in diesem Fall zu erfassen, schreiben Sie stattdessen eine Erfassungsanweisung für FormatException.

Wir haben in diesem Thema gezeigt, wie die System.Net.Http.HttpClient-Klasse für das Senden einer GET-Anforderung an einen Webservice verwendet wird und wie die Antwort mit der System.Net.Http.HttpResponseMessage-Klasse und der System.Net.Http.HttpContent-Klasse abgerufen wird.

HttpClientBasic-Beispiel


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


Sie können die System.Net.Http.HttpClientHandler-Klasse mit der System.Net.Http.HttpClient-Klasse verwenden, um in der HTTP-Anforderungen Optionen festzulegen. Weitere Informationen hierzu finden Sie unter Verwenden von HttpClient-Verbindungen.

Verwandte Themen

Weitere Ressourcen
Herstellen von Verbindungen mit Webdiensten
Konfigurieren von Netzwerkisolationsfunktionen
Aktivieren von Loopback und Debuggen der Netzwerkisolation.
Sichern von System.Net.Http.HttpClient-Verbindungen
Verwenden von System.Net.Http.HttpClient-Verbindungen
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:
© 2014 Microsoft. Alle Rechte vorbehalten.