HttpClient (på engelska)

viktiga API:er

• HttpClient
• Windows. Web.Http
• Windows. Web.Http.HttpResponseMessage

Använd HttpClient och resten av Windows. Web.Http-namnområdes-API för att skicka och ta emot information med hjälp av HTTP 2.0- och HTTP 1.1-protokollen.

Översikt över HttpClient och Windows. Web.Http-namnrymd

Klasserna i Windows. Web.Http-namnrymd och relaterade Windows. Web.Http.Headers och Windows. Web.Http.Filters-namnområden tillhandahåller ett programmeringsgränssnitt för Windows appar som fungerar som en HTTP-klient för att utföra grundläggande GET-begäranden eller implementera mer avancerade HTTP-funktioner som anges nedan.

• Metoder för vanliga verb (DELETE, GET, PUT och POST). Var och en av dessa begäranden skickas som en asynkron åtgärd.

• Stöd för vanliga autentiseringsinställningar och mönster.

• Åtkomst till SSL-information (Secure Sockets Layer) om transporten.

• Möjlighet att inkludera anpassade filter i avancerade appar.

• Möjlighet att hämta, ställa in och ta bort cookies.

• HTTP-begärandeförloppsinformation tillgänglig på asynkrona metoder.

Klassen Windows.Web.Http.HttpRequestMessage representerar en HTTP-begäran som skickas av Windows.Web.Http.HttpClient. Windows. Klassen Web.Http.HttpResponseMessage representerar ett HTTP-svarsmeddelande som tagits emot från en HTTP-begäran. HTTP-meddelanden definieras i RFC 2616 av IETF.

Windows. Web.Http-namnrymd representerar HTTP-innehåll som HTTP-entitetstext och rubriker, inklusive cookies. HTTP-innehåll kan associeras med en HTTP-begäran eller ett HTTP-svar. Windows. Web.Http-namnområdet innehåller ett antal olika klasser som representerar HTTP-innehåll.

• HttpBufferContent. Innehåll som en buffert
• HttpFormUrlEncodedContent. Innehåll som namn- och värdetupler kodade med MIME-typen application/x-www-form-urlencoded
• HttpMultipartContent. Innehåll i form av MIME-typen multipart/* .
• HttpMultipartFormDataContent. Innehåll som kodas som MIME-typ för flera delar/formulärdata .
• HttpStreamContent. Innehåll som en ström (den interna typen används av HTTP GET-metoden för att ta emot data och HTTP POST-metoden för att ladda upp data)
• HttpStringContent. Innehåll som en sträng.
• IHttpContent – ett basgränssnitt för utvecklare för att skapa egna innehållsobjekt

Kodfragmentet i avsnittet "Skicka en enkel GET-begäran via HTTP" använder klassen HttpStringContent för att representera HTTP-svaret från en HTTP GET-begäran som en sträng.

Windows. Web.Http.Headers-namnområdet stöder skapande av HTTP-huvuden och cookies, som sedan associeras som egenskaper med HttpRequestMessage- och HttpResponseMessage-objekt.

Skicka en enkel GET-begäran via HTTP

Som vi nämnde tidigare i den här artikeln Windows. Med Web.Http-namnrymden kan Windows appar skicka GET-begäranden. Följande kodfragment visar hur du skickar en GET-begäran till http://www.contoso.com med hjälp av Windows. Klassen Web.Http.HttpClient och Windows. Web.Http.HttpResponseMessage-klassen för att läsa svaret från GET-begäran.

//Create an HTTP client object
Windows.Web.Http.HttpClient httpClient = new Windows.Web.Http.HttpClient();

//Add a user-agent header to the GET request.
var headers = httpClient.DefaultRequestHeaders;

//The safe way to add a header value is to use the TryParseAdd method and verify the return value is true,
//especially if the header value is coming from user input.
string header = "MyApp/1.0";
if (!headers.UserAgent.TryParseAdd(header))
{
    throw new Exception("Invalid header value: " + header);
}

Uri requestUri = new Uri("http://www.contoso.com");

//Send the GET request asynchronously and retrieve the response as a string.
Windows.Web.Http.HttpResponseMessage httpResponse = new Windows.Web.Http.HttpResponseMessage();
string httpResponseBody = "";

try
{
    //Send the GET request
    httpResponse = await httpClient.GetAsync(requestUri);
    httpResponse.EnsureSuccessStatusCode();
    httpResponseBody = await httpResponse.Content.ReadAsStringAsync();
}
catch (Exception ex)
{
    httpResponseBody = "Error: " + ex.HResult.ToString("X") + " Message: " + ex.Message;
}

// pch.h
#pragma once
#include <winrt/Windows.Foundation.h>
#include <winrt/Windows.Web.Http.Headers.h>

// main.cpp : Defines the entry point for the console application.
#include "pch.h"
#include <iostream>
using namespace winrt;
using namespace Windows::Foundation;

int main()
{
    init_apartment();

    // Create an HttpClient object.
    Windows::Web::Http::HttpClient httpClient;

    // Add a user-agent header to the GET request.
    auto headers{ httpClient.DefaultRequestHeaders() };

    // The safe way to add a header value is to use the TryParseAdd method, and verify the return value is true.
    // This is especially important if the header value is coming from user input.
    std::wstring header{ L"MyApp/1.0" };
    if (!headers.UserAgent().TryParseAdd(header))
    {
        throw L"Invalid header value: " + header;
    }

    Uri requestUri{ L"http://www.contoso.com" };

    // Send the GET request asynchronously, and retrieve the response as a string.
    Windows::Web::Http::HttpResponseMessage httpResponseMessage;
    std::wstring httpResponseBody;

    try
    {
        // Send the GET request.
        httpResponseMessage = httpClient.GetAsync(requestUri).get();
        httpResponseMessage.EnsureSuccessStatusCode();
        httpResponseBody = httpResponseMessage.Content().ReadAsStringAsync().get();
    }
    catch (winrt::hresult_error const& ex)
    {
        httpResponseBody = ex.message();
    }
    std::wcout << httpResponseBody;
}

Skicka binärdata med POST över HTTP

I C++/WinRT-kodexemplet nedan visas hur du använder formulärdata och en POST-begäran om att skicka en liten mängd binära data som en filuppladdning till en webbserver. Koden använder klassen HttpBufferContent för att representera binära data och klassen HttpMultipartFormDataContent för att representera formulärdata i flera delar.

// pch.h
#pragma once
#include <winrt/Windows.Foundation.h>
#include <winrt/Windows.Security.Cryptography.h>
#include <winrt/Windows.Storage.Streams.h>
#include <winrt/Windows.Web.Http.Headers.h>

// main.cpp : Defines the entry point for the console application.
#include "pch.h"
#include <iostream>
#include <sstream>
using namespace winrt;
using namespace Windows::Foundation;
using namespace Windows::Storage::Streams;

int main()
{
    init_apartment();

    auto buffer{
        Windows::Security::Cryptography::CryptographicBuffer::ConvertStringToBinary(
            L"A sentence of text to encode into binary to serve as sample data.",
            Windows::Security::Cryptography::BinaryStringEncoding::Utf8
        )
    };
    Windows::Web::Http::HttpBufferContent binaryContent{ buffer };
    // You can use the 'image/jpeg' content type to represent any binary data;
    // it's not necessarily an image file.
    binaryContent.Headers().Append(L"Content-Type", L"image/jpeg");

    Windows::Web::Http::Headers::HttpContentDispositionHeaderValue disposition{ L"form-data" };
    binaryContent.Headers().ContentDisposition(disposition);
    // The 'name' directive contains the name of the form field representing the data.
    disposition.Name(L"fileForUpload");
    // Here, the 'filename' directive is used to indicate to the server a file name
    // to use to save the uploaded data.
    disposition.FileName(L"file.dat");

    Windows::Web::Http::HttpMultipartFormDataContent postContent;
    postContent.Add(binaryContent); // Add the binary data content as a part of the form data content.

    // Send the POST request asynchronously, and retrieve the response as a string.
    Windows::Web::Http::HttpResponseMessage httpResponseMessage;
    std::wstring httpResponseBody;

    try
    {
        // Send the POST request.
        Uri requestUri{ L"https://www.contoso.com/post" };
        Windows::Web::Http::HttpClient httpClient;
        httpResponseMessage = httpClient.PostAsync(requestUri, postContent).get();
        httpResponseMessage.EnsureSuccessStatusCode();
        httpResponseBody = httpResponseMessage.Content().ReadAsStringAsync().get();
    }
    catch (winrt::hresult_error const& ex)
    {
        httpResponseBody = ex.message();
    }
    std::wcout << httpResponseBody;
}

Om du vill PUBLICERA innehållet i en faktisk binär fil (i stället för explicita binära data som används ovan) blir det enklare att använda ett HttpStreamContent-objekt . Konstruera en och skicka som argument till konstruktorn det värde som returneras från ett anrop till StorageFile.OpenReadAsync. Den metoden returnerar en ström för dataene i din binärfil.

Om du laddar upp en stor fil (större än cirka 10 MB) rekommenderar vi också att du använder API:erna för Windows Runtime bakgrundsöverföring.

POST JSON-data via HTTP

I följande exempel skickas en del JSON till en slutpunkt och sedan skrivs svarstexten ut.

using System;
using System.Diagnostics;
using System.Threading.Tasks;
using Windows.Storage.Streams;
using Windows.Web.Http;

private async Task TryPostJsonAsync()
{
    try
    {
        // Construct the HttpClient and Uri. This endpoint is for test purposes only.
        HttpClient httpClient = new HttpClient();
        Uri uri = new Uri("https://www.contoso.com/post");

        // Construct the JSON to post.
        HttpStringContent content = new HttpStringContent(
            "{ \"firstName\": \"Eliot\" }",
            UnicodeEncoding.Utf8,
            "application/json");

        // Post the JSON and wait for a response.
        HttpResponseMessage httpResponseMessage = await httpClient.PostAsync(
            uri,
            content);

        // Make sure the post succeeded, and write out the response.
        httpResponseMessage.EnsureSuccessStatusCode();
        var httpResponseBody = await httpResponseMessage.Content.ReadAsStringAsync();
        Debug.WriteLine(httpResponseBody);
    }
    catch (Exception ex)
    {
        // Write out any exceptions.
        Debug.WriteLine(ex);
    }
}

// pch.h
#pragma once
#include <winrt/Windows.Foundation.h>
#include <winrt/Windows.Security.Cryptography.h>
#include <winrt/Windows.Storage.Streams.h>
#include <winrt/Windows.Web.Http.Headers.h>

// main.cpp : Defines the entry point for the console application.
#include "pch.h"
#include <iostream>
#include <sstream>
using namespace winrt;
using namespace Windows::Foundation;
using namespace Windows::Storage::Streams;

int main()
{
    init_apartment();

    Windows::Web::Http::HttpResponseMessage httpResponseMessage;
    std::wstring httpResponseBody;

    try
    {
        // Construct the HttpClient and Uri. This endpoint is for test purposes only.
        Windows::Web::Http::HttpClient httpClient;
        Uri requestUri{ L"https://www.contoso.com/post" };

        // Construct the JSON to post.
        Windows::Web::Http::HttpStringContent jsonContent(
            L"{ \"firstName\": \"Eliot\" }",
            UnicodeEncoding::Utf8,
            L"application/json");

        // Post the JSON, and wait for a response.
        httpResponseMessage = httpClient.PostAsync(
            requestUri,
            jsonContent).get();

        // Make sure the post succeeded, and write out the response.
        httpResponseMessage.EnsureSuccessStatusCode();
        httpResponseBody = httpResponseMessage.Content().ReadAsStringAsync().get();
        std::wcout << httpResponseBody.c_str();
    }
    catch (winrt::hresult_error const& ex)
    {
        std::wcout << ex.message().c_str();
    }
}

Undantag i Windows. Web.Http

Ett undantag utlöses när en ogiltig sträng för en URI (Uniform Resource Identifier) skickas till konstruktorn för Windows. Foundation.Uri-objekt.

.NET: Typen Windows.Foundation.Uri visas som System.Uri i C# och VB.

I C# och Visual Basic kan du undvika det här felet genom att använda klassen System.Uri i .NET 4.5 och någon av metoderna System.Uri.TryCreate för att testa strängen som tas emot från en användare innan URI:n skapas.

I C++ finns det ingen metod för att försöka parsa en sträng till en URI. Om en app får indata från användaren för Windows. Foundation.Uri, konstruktorn ska vara i ett try/catch-block. Om ett undantag utlöses kan appen meddela användaren och begära ett nytt värdnamn.

Windows. Web.Http saknar en bekvämlighetsfunktion. Därför måste en app som använder HttpClient och andra klasser i det här namnområdet använda HRESULT-värdet .

I appar som använder C++/WinRT representerar winrt::hresult_error struct ett undantag som uppstod under appkörningen. Funktionen winrt::hresult_error::code returnerar den HRESULT som är tilldelad det specifika undantaget. Funktionen winrt::hresult_error::message returnerar den systemspecifika sträng som är associerad med HRESULT-värdet . Mer information finns i Felhantering med C++/WinRT

Möjliga HRESULT-värden visas i winerror.h-huvudfilen . Din app kan filtrera efter specifika HRESULT-värden för att ändra appens beteende beroende på orsaken till undantaget.

I appar som använder .NET Framework 4.5 i C#, VB.NET representerar System.Exception ett fel under appkörningen när ett undantag inträffar. Egenskapen System.Exception.HResult returnerar den HRESULT som tilldelats det specifika undantaget. Egenskapen System.Exception.Message returnerar meddelandet som beskriver undantaget.

C++/CX har ersatts av C++/WinRT. Men i appar som använder C++/CX representerar plattform::Undantag ett fel under appkörningen när ett undantag inträffar. Egenskapen Platform::Exception::HResult returnerar den HRESULT som tilldelats det specifika undantaget. Egenskapen Platform::Exception::Message returnerar den systemspecifika strängen som är associerad med HRESULT-värdet .

Vid de flesta fel vid parametervalidering returneras HRESULT-värdet E_INVALIDARG. För vissa otillåtna metodanrop returneras HRESULT-värdet E_ILLEGAL_METHOD_CALL.