PATCH Żądania asynchroniczne z Windows.Web.Http.HttpClient klasa

Question

Muszę wykonać żądanie PATCH z klasą Windows.Web.Http.HttpClient i nie ma oficjalnej dokumentacji, jak to zrobić. Jak mogę to zrobić?

Answer 1

znalazłem jak zrobić „zwyczaj” PATCH wniosek z poprzedniego System.Net.Http.HttpClient klasy here, a potem bawił się aż zrobiłem to działa w klasie Windows.Web.Http.HttpClient, tak:

public async Task<HttpResponseMessage> PatchAsync(HttpClient client, Uri requestUri, IHttpContent iContent) { 
    var method = new HttpMethod("PATCH"); 

    var request = new HttpRequestMessage(method, requestUri) { 
     Content = iContent 
    }; 

    HttpResponseMessage response = new HttpResponseMessage(); 
    // In case you want to set a timeout 
    //CancellationToken cancellationToken = new CancellationTokenSource(60).Token; 

    try { 
     response = await client.SendRequestAsync(request); 
     // If you want to use the timeout you set 
     //response = await client.SendRequestAsync(request).AsTask(cancellationToken); 
    } catch(TaskCanceledException e) { 
     Debug.WriteLine("ERROR: " + e.ToString()); 
    } 

    return response; 
} 

Answer 2

można napisać Ta sama metoda jak metoda rozszerzenie, dzięki czemu można powoływać się bezpośrednio na obiekcie httpclient:

public static class HttpClientExtensions 
{ 
    public static async Task<HttpResponseMessage> PatchAsync(this HttpClient client, Uri requestUri, HttpContent iContent) 
    { 
     var method = new HttpMethod("PATCH"); 
     var request = new HttpRequestMessage(method, requestUri) 
     { 
      Content = iContent 
     }; 

     HttpResponseMessage response = new HttpResponseMessage(); 
     try 
     { 
      response = await client.SendAsync(request); 
     } 
     catch (TaskCanceledException e) 
     { 
      Debug.WriteLine("ERROR: " + e.ToString()); 
     } 

     return response; 
    } 
} 

Zastosowanie:

var responseMessage = await httpClient.PatchAsync(new Uri("testUri"), httpContent); 

Answer 3

Chciałbym rozszerzyć odpowiedź @ alexander-pacha i zasugerować dodanie następnej klasy rozszerzenia gdzieś we wspólnej bibliotece. Czy jest to wspólna biblioteka dla projektu/klienta/frameworka/... jest czymś, co sam musisz sobie wyobrazić.

public static class HttpClientExtensions 
    { 
     /// <summary> 
     /// Send a PATCH request to the specified Uri as an asynchronous operation. 
     /// </summary> 
     /// 
     /// <returns> 
     /// Returns <see cref="T:System.Threading.Tasks.Task`1"/>.The task object representing the asynchronous operation. 
     /// </returns> 
     /// <param name="client">The instantiated Http Client <see cref="HttpClient"/></param> 
     /// <param name="requestUri">The Uri the request is sent to.</param> 
     /// <param name="content">The HTTP request content sent to the server.</param> 
     /// <exception cref="T:System.ArgumentNullException">The <paramref name="client"/> was null.</exception> 
     /// <exception cref="T:System.ArgumentNullException">The <paramref name="requestUri"/> was null.</exception> 
     public static Task<HttpResponseMessage> PatchAsync(this HttpClient client, string requestUri, HttpContent content) 
     { 
      return client.PatchAsync(CreateUri(requestUri), content); 
     } 

     /// <summary> 
     /// Send a PATCH request to the specified Uri as an asynchronous operation. 
     /// </summary> 
     /// 
     /// <returns> 
     /// Returns <see cref="T:System.Threading.Tasks.Task`1"/>.The task object representing the asynchronous operation. 
     /// </returns> 
     /// <param name="client">The instantiated Http Client <see cref="HttpClient"/></param> 
     /// <param name="requestUri">The Uri the request is sent to.</param> 
     /// <param name="content">The HTTP request content sent to the server.</param> 
     /// <exception cref="T:System.ArgumentNullException">The <paramref name="client"/> was null.</exception> 
     /// <exception cref="T:System.ArgumentNullException">The <paramref name="requestUri"/> was null.</exception> 
     public static Task<HttpResponseMessage> PatchAsync(this HttpClient client, Uri requestUri, HttpContent content) 
     { 
      return client.PatchAsync(requestUri, content, CancellationToken.None); 
     } 
     /// <summary> 
     /// Send a PATCH request with a cancellation token as an asynchronous operation. 
     /// </summary> 
     /// 
     /// <returns> 
     /// Returns <see cref="T:System.Threading.Tasks.Task`1"/>.The task object representing the asynchronous operation. 
     /// </returns> 
     /// <param name="client">The instantiated Http Client <see cref="HttpClient"/></param> 
     /// <param name="requestUri">The Uri the request is sent to.</param> 
     /// <param name="content">The HTTP request content sent to the server.</param> 
     /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param> 
     /// <exception cref="T:System.ArgumentNullException">The <paramref name="client"/> was null.</exception> 
     /// <exception cref="T:System.ArgumentNullException">The <paramref name="requestUri"/> was null.</exception> 
     public static Task<HttpResponseMessage> PatchAsync(this HttpClient client, string requestUri, HttpContent content, CancellationToken cancellationToken) 
     { 
      return client.PatchAsync(CreateUri(requestUri), content, cancellationToken); 
     } 

     /// <summary> 
     /// Send a PATCH request with a cancellation token as an asynchronous operation. 
     /// </summary> 
     /// 
     /// <returns> 
     /// Returns <see cref="T:System.Threading.Tasks.Task`1"/>.The task object representing the asynchronous operation. 
     /// </returns> 
     /// <param name="client">The instantiated Http Client <see cref="HttpClient"/></param> 
     /// <param name="requestUri">The Uri the request is sent to.</param> 
     /// <param name="content">The HTTP request content sent to the server.</param> 
     /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param> 
     /// <exception cref="T:System.ArgumentNullException">The <paramref name="client"/> was null.</exception> 
     /// <exception cref="T:System.ArgumentNullException">The <paramref name="requestUri"/> was null.</exception> 
     public static Task<HttpResponseMessage> PatchAsync(this HttpClient client, Uri requestUri, HttpContent content, CancellationToken cancellationToken) 
     { 
      return client.SendAsync(new HttpRequestMessage(new HttpMethod("PATCH"), requestUri) 
      { 
       Content = content 
      }, cancellationToken); 
     } 

     private static Uri CreateUri(string uri) 
     { 
      return string.IsNullOrEmpty(uri) ? null : new Uri(uri, UriKind.RelativeOrAbsolute); 
     } 
    } 

ten sposób nie jesteś w oczekiwaniu na wykonanie i trzyma się w jakiejś klasie statycznej przedłużacza, ale sobie z tym poradzić, jak gdybyś naprawdę robi PostAsync lub połączenia PutAsync. Masz również do dyspozycji te same przeciążenia i pozwalasz HttpClientowi obsłużyć wszystko, co zaprojektowałeś.

Answer 4

go do pracy trzeba przekazać treść tak:

HttpContent httpContent = new StringContent ("Twój JSON-String", Encoding.UTF8 "application/json-łata + json");