Cliente HTTP

API importantes

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

Use HttpClient y el resto de la API del espacio de nombres Windows.Web.Http para enviar y recibir información mediante los protocolos HTTP 2.0 y HTTP 1.1.

Información general sobre HttpClient y el espacio de nombres Windows.Web.Http

Las clases del espacio de nombres Windows.Web.Http y de los espacios de nombres relacionados Windows.Web.Http.Headers y Windows.Web.Http.Filters proporcionan una interfaz de programación para aplicaciones de Windows que actúan como cliente HTTP para realizar solicitudes GET básicas o implementar funcionalidades HTTP más avanzadas que se indican a continuación.

• Métodos para verbos comunes (DELETE, GET, PUT y POST). Cada una de estas solicitudes se envía como una operación asincrónica.

• Compatibilidad con patrones y configuraciones de autenticación comunes.

• Acceso a los detalles de Secure Sockets Layer (SSL) del transporte.

• Capacidad de incluir filtros personalizados en aplicaciones avanzadas.

• Capacidad de obtener, establecer y eliminar cookies.

• Información de progreso de la solicitud HTTP disponible en métodos asincrónicos.

La clase Windows.Web.Http.HttpRequestMessage representa un mensaje de solicitud de HTTP enviado por Windows.Web.Http.HttpClient. La clase Windows.Web.Http.HttpResponseMessage representa un mensaje de respuesta HTTP recibido en respuesta a una solicitud HTTP. IETF define los mensajes HTTP en RFC 2616 .

El espacio de nombres Windows.Web.Http representa el contenido HTTP en forma de cuerpo y encabezados de entidad HTTP, incluidas las cookies. El contenido HTTP se puede asociar a una solicitud HTTP o a una respuesta HTTP. El espacio de nombres Windows.Web.Http proporciona varias clases para representar el contenido HTTP.

• HttpBufferContent. Contenido como un búfer
• HttpFormUrlEncodedContent. Contenido como tuplas de nombre y valor codificadas con el tipo MIME application/x-www-form-urlencoded.
• HttpMultipartContent. Contenido en forma de tipo MIME multipart/*.
• HttpMultipartFormDataContent. Contenido que se codifica como el tipo MIME multipart/form-data .
• HttpStreamContent. Contenido como secuencia (el método HTTP GET usa el tipo interno para recibir datos y el método HTTP POST para cargar datos)
• HttpStringContent. Contenido como una cadena de texto.
• IHttpContent : una interfaz base para que los desarrolladores creen sus propios objetos de contenido

El fragmento de código de la sección "Enviar una solicitud GET simple a través de HTTP" usa la clase HttpStringContent para representar la respuesta HTTP de una solicitud HTTP GET como una cadena.

El espacio de nombres Windows.Web.Http.Headers admite la creación de encabezados HTTP y cookies, que luego se asocian como propiedades a los objetos HttpRequestMessage y HttpResponseMessage.

Envío de una solicitud GET simple a través de HTTP

Como se mencionó anteriormente en este artículo, el espacio de nombres Windows.Web.Http permite que las aplicaciones de Windows envíen solicitudes GET. En el siguiente fragmento de código se muestra cómo enviar una solicitud GET a http://www.contoso.com mediante la clase Windows.Web.Http.HttpClient y la clase Windows.Web.Http.HttpResponseMessage para leer la respuesta de la solicitud GET.

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

Enviar datos binarios mediante HTTP POST

En el ejemplo de código de C++/WinRT siguiente se muestra el uso de datos de formulario y una solicitud POST para enviar una pequeña cantidad de datos binarios como carga de archivos a un servidor web. El código usa la clase HttpBufferContent para representar los datos binarios y la clase HttpMultipartFormDataContent para representar los datos de formulario de varias partes.

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

Para PUBLICAR el contenido de un archivo binario real (en lugar de los datos binarios explícitos usados anteriormente), le resultará más fácil usar un objeto HttpStreamContent . Construya uno y, como argumento para su constructor, pase el valor devuelto desde una llamada a StorageFile.OpenReadAsync. Ese método devuelve un flujo de los datos de tu archivo binario.

Además, si va a cargar un archivo grande (más de 10 MB), se recomienda usar las API de transferencia en segundo plano de Windows Runtime.

Enviar datos JSON mediante HTTP POST

En el ejemplo siguiente se envía un JSON a un extremo y, a continuación, se muestra el cuerpo de la respuesta.

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

Excepciones en Windows. Web.Http

Se produce una excepción cuando se pasa una cadena no válida para un identificador uniforme de recursos (URI) al constructor del Windows. Objeto Foundation.Uri.

.NET: El tipo Windows.Foundation.Uri aparece como System.Uri en C# y VB.

En C# y Visual Basic, este error se puede evitar mediante el uso de la clase System.Uri en el .NET 4.5 y uno de los métodos System.Uri.TryCreate para probar la cadena recibida de un usuario antes de que se construya el URI.

En C++, no hay ningún método para probar y analizar una cadena en un URI. Si una aplicación recibe información del usuario relativa a Windows.Foundation.Uri, el constructor debe estar en un bloque Try/Catch. Si se produce una excepción, la aplicación puede notificar al usuario y solicitar un nuevo nombre de host.

El Windows. Web.Http carece de una función de conveniencia. Por lo tanto, una aplicación que usa HttpClient y otras clases de este espacio de nombres debe usar el valor HRESULT .

En las aplicaciones que usan C++/WinRT, la estructura winrt::hresult_error representa una excepción generada durante la ejecución de la aplicación. La función winrt::hresult_error::code devuelve el VALOR HRESULT asignado a la excepción específica. La función winrt::hresult_error::message devuelve la cadena proporcionada por el sistema asociada al valor HRESULT . Para obtener más información, consulta Control de errores con C++/WinRT

Los posibles valores HRESULT se enumeran en el archivo de encabezado Winerror.h . La aplicación puede filtrar por valores HRESULT específicos para modificar el comportamiento de la aplicación en función de la causa de la excepción.

En las aplicaciones que usan .NET Framework 4.5 en C#, VB.NET, System.Exception representa un error durante la ejecución de la aplicación cuando se produce una excepción. La propiedad System.Exception.HResult devuelve el VALOR HRESULT asignado a la excepción específica. La propiedad System.Exception.Message devuelve el mensaje que describe la excepción.

C++/CX se ha reemplazado por C++/WinRT. Pero en las aplicaciones que usan C++/CX, Platform::Exception representa un error durante la ejecución de la aplicación cuando se produce una excepción. La propiedad Platform::Exception::HResult devuelve el valor HRESULT asignado a la excepción específica. La propiedad Platform::Exception::Message devuelve la cadena proporcionada por el sistema asociada al valor HRESULT .

Para la mayoría de los errores de validación de parámetros, el valor HRESULT devuelto es E_INVALIDARG. Para algunas llamadas ilegales a métodos, el HRESULT devuelto es E_ILLEGAL_METHOD_CALL.