PATCH demandes Asynchrones avec Windows.Web.Http.La classe HttpClient

J'ai besoin de faire un PATCH demande avec le Windows.Web.Http.HttpClient classe et il n'y a pas de documentation officielle sur la façon de le faire. Comment puis-je faire cela?

InformationsquelleAutor Schrödinger's Box | 2014-10-06
  1. 71

    J'ai trouvé comment faire un "custom" PATCH demande avec la précédente System.Net.Http.HttpClient classe ici, puis jouait avec jusqu'à ce que j'ai fait le travail dans le Windows.Web.Http.HttpClient classe, comme suit:

    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;
}
    • au lieu de `` HttpResponseMessage response = new HttpResponseMessage (); ` " utiliser `` var response = par défaut(HttpResponseMessage); ``
    InformationsquelleAutor Schrödinger's Box
  2. 46

    Mise à jour: Voir SSX-SL33PY réponse ci-dessous pour une bien meilleure solution, qui fait la même chose.

    Vous pouvez écrire la même méthode que la méthode d'extension, de sorte que vous pouvez les appeler directement sur l'objet 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;
   }
}

    Utilisation:

    var responseMessage = await httpClient.PatchAsync(new Uri("testUri"), httpContent);
    • comment transmettez-vous le contenu?
    • Vous voyez la deuxième paramètre? Essayez quelque chose comme ceci: HttpContent httpContent = new StringContent("Your JSON-String", Encoding.UTF8, "application/json"); pour les chaînes-Matières.
    • Corrigez-moi si je me trompe, mais le PATCH méthode signifie que vous ne modifier que les données spécifiques au sein du JSON. Comment modifier, disons, juste le nom d'un produit? Si par "Votre JSON-Chaîne" tu veux dire que l'ensemble du JSON, puis je suis confus. J'ai essayé d'ajouter une propriété unique comme HttpContent content = new StringContent("{\"name\":\"John Doe\"", Encoding.UTF8, "application/json"); mais le contenu n'est pas ajouté à la demande.
    InformationsquelleAutor Alexander Pacha
  3. 30

    Je voudrais étendre sur @alexandre-pacha réponse et de suggérer l'ajout d'extension suivants de la classe, quelque part dans une bibliothèque commune. Que ce soit une bibliothèque commune pour un projet /client /cadre/... est quelque chose que vous aurez à faire sur votre propre.

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

    De cette façon, vous n'êtes pas en attente et la tenue d'exécution dans certains statique de la classe d'extension, mais vous gérer qui, comme si vous étiez vraiment en train de faire un PostAsync ou un PutAsync appel. Vous avez également la même surcharges à votre disposition et vous laissons le HttpClient tout gérer, il a été conçu pour gérer.

    • Cela ressemble beaucoup. Vous devriez envisager la création d'une Pull-Request sur Github dans le dépôt officiel de la .NET Framework, comme ils accueillent des contributions: github.com/dotnet/corefx/blob/master/src/System.Net.Http/src/...
    • Edit: Quelqu'un me battre pour elle, il a été ajouté à la mise en pension est lié par quelqu'un d'autre.
    InformationsquelleAutor SSX-SL33PY
  4. 1

    Pour qu'il fonctionne, vous devez transmettre le contenu de ce type:

    HttpContent httpContent = new StringContent("Your JSON-String", Encoding.UTF8, "application/json-patch+json");
    InformationsquelleAutor Claire G