Comment utiliser System.Net.HttpClient pour publier un type complexe?

J'ai un type complexe personnalisé avec lequel je souhaite travailler à l'aide de l'API Web.

public class Widget
{
    public int ID { get; set; }
    public string Name { get; set; }
    public decimal Price { get; set; }
}

Et voici ma méthode de contrôleur API Web. Je veux publier cet objet comme ceci:

public class TestController : ApiController
{
    // POST /api/test
    public HttpResponseMessage<Widget> Post(Widget widget)
    {
        widget.ID = 1; // hardcoded for now. TODO: Save to db and return newly created ID

        var response = new HttpResponseMessage<Widget>(widget, HttpStatusCode.Created);
        response.Headers.Location = new Uri(Request.RequestUri, "/api/test/" + widget.ID.ToString());
        return response;
    }
}

Et maintenant, j'aimerais utiliser System.Net.HttpClientpour faire l'appel à la méthode. Cependant, je ne sais pas quel type d'objet passer dans la PostAsyncméthode et comment le construire. Voici un exemple de code client.

var client = new HttpClient();
HttpContent content = new StringContent("???"); // how do I construct the Widget to post?
client.PostAsync("http://localhost:44268/api/test", content).ContinueWith(
    (postTask) =>
    {
        postTask.Result.EnsureSuccessStatusCode();
    });

Comment créer l' HttpContentobjet de manière à ce que l'API Web le comprenne?

Le générique HttpRequestMessage<T>a été supprimé . Ce :

new HttpRequestMessage<Widget>(widget)

sera pas de travail plus .

Au lieu de cela, à partir de cet article , l'équipe ASP.NET a inclus de nouveaux appels pour prendre en charge cette fonctionnalité:

HttpClient.PostAsJsonAsync<T>(T value) sends “application/json”
HttpClient.PostAsXmlAsync<T>(T value) sends “application/xml”

Ainsi, le nouveau code ( de Dunston ) devient:

Widget widget = new Widget()
widget.Name = "test"
widget.Price = 1;

HttpClient client = new HttpClient();
client.BaseAddress = new Uri("http://localhost:44268");
client.PostAsJsonAsync("api/test", widget)
    .ContinueWith((postTask) => postTask.Result.EnsureSuccessStatusCode() );

Vous devriez utiliser la SendAsyncméthode à la place, c'est une méthode générique, qui sérialise l'entrée du service

Widget widget = new Widget()
widget.Name = "test"
widget.Price = 1;

HttpClient client = new HttpClient();
client.BaseAddress = new Uri("http://localhost:44268/api/test");
client.SendAsync(new HttpRequestMessage<Widget>(widget))
    .ContinueWith((postTask) => postTask.Result.EnsureSuccessStatusCode() );

Si vous ne voulez pas créer la classe concrète, vous pouvez la créer avec la FormUrlEncodedContentclasse

var client = new HttpClient();

// This is the postdata
var postData = new List<KeyValuePair<string, string>>();
postData.Add(new KeyValuePair<string, string>("Name", "test"));
postData.Add(new KeyValuePair<string, string>("Price ", "100"));

HttpContent content = new FormUrlEncodedContent(postData); 

client.PostAsync("http://localhost:44268/api/test", content).ContinueWith(
    (postTask) =>
    {
        postTask.Result.EnsureSuccessStatusCode();
    });

Remarque: vous devez faire de votre identifiant un int nullable ( int?)

Notez que si vous utilisez une bibliothèque de classes portable, HttpClient n'aura pas de méthode PostAsJsonAsync . Pour publier un contenu au format JSON à l'aide d'une bibliothèque de classes portable, vous devrez procéder comme suit:

HttpClient client = new HttpClient();
HttpContent contentPost = new StringContent(argsAsJson, Encoding.UTF8, 
"application/json");

await client.PostAsync(new Uri(wsUrl), contentPost).ContinueWith(
(postTask) => postTask.Result.EnsureSuccessStatusCode());

Si vous voulez les types de méthodes de commodité mentionnés dans d'autres réponses mais que vous avez besoin de portabilité (ou même si vous ne le faites pas), vous voudrez peut-être vérifier Flurl [divulgation: je suis l'auteur]. Il enveloppe (finement) HttpClientet Json.NET et ajoute du sucre courant et d'autres goodies, y compris des assistants de test intégrés .

Publier en JSON:

var resp = await "http://localhost:44268/api/test".PostJsonAsync(widget);

ou encodé en URL:

var resp = await "http://localhost:44268/api/test".PostUrlEncodedAsync(widget);

Les deux exemples ci-dessus renvoient un HttpResponseMessage, mais Flurl inclut des méthodes d'extension pour renvoyer d'autres choses si vous voulez juste aller droit au but:

T poco = await url.PostJsonAsync(data).ReceiveJson<T>();
dynamic d = await url.PostUrlEncodedAsync(data).ReceiveJson();
string s = await url.PostUrlEncodedAsync(data).ReceiveString();

Flurl est disponible sur NuGet:

PM> Install-Package Flurl.Http

Après avoir étudié de nombreuses alternatives, je suis tombé sur une autre approche, adaptée à la version API 2.0.

(VB.NET est mon préféré, sooo ...)

Public Async Function APIPut_Response(ID as Integer, MyWidget as Widget) as Task(Of HttpResponseMessage)
    Dim DesiredContent as HttpContent = New StringContent(JsonConvert.SerializeObject(MyWidget))
    Return Await APIClient.PutAsync(String.Format("api/widget/{0}", ID), DesiredContent)
End Function

Bonne chance! Pour moi, cela a fonctionné (à la fin!).

Cordialement, Peter

Je pense que vous pouvez faire ceci:

var client = new HttpClient();
HttpContent content = new Widget();
client.PostAsync<Widget>("http://localhost:44268/api/test", content, new FormUrlEncodedMediaTypeFormatter())
    .ContinueWith((postTask) => { postTask.Result.EnsureSuccessStatusCode(); });

Au cas où quelqu'un comme moi ne comprendrait pas vraiment de quoi parlent tout ce qui précède, je donne un exemple simple qui fonctionne pour moi. Si vous avez une API Web dont l'url est " http://somesite.com/verifyAddress ", il s'agit d'une méthode de publication et vous devez lui transmettre un objet d'adresse. Vous souhaitez appeler cette API dans votre code. Voici ce que vous pouvez faire.

    public Address verifyAddress(Address address)
    {
        this.client = new HttpClient();
        client.BaseAddress = new Uri("http://somesite.com/");
        client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
        var urlParm = URL + "verifyAddress";
        response = client.PostAsJsonAsync(urlParm,address).Result;
        var dataObjects = response.IsSuccessStatusCode ? response.Content.ReadAsAsync<Address>().Result : null;
        return dataObjects;
    }

C'est le code avec lequel je me suis retrouvé, basé sur les autres réponses ici. Ceci est pour un HttpPost qui reçoit et répond avec des types complexes:

Task<HttpResponseMessage> response = httpClient.PostAsJsonAsync(
                       strMyHttpPostURL,
                       new MyComplexObject { Param1 = param1, Param2 = param2}).ContinueWith((postTask) => postTask.Result.EnsureSuccessStatusCode());
                    //debug:
                    //String s = response.Result.Content.ReadAsStringAsync().Result;
                    MyOtherComplexType moct = (MyOtherComplexType)JsonConvert.DeserializeObject(response.Result.Content.ReadAsStringAsync().Result, typeof(MyOtherComplexType));

Faites un appel de service comme celui-ci:

public async void SaveActivationCode(ActivationCodes objAC)
{
    var client = new HttpClient();
    client.BaseAddress = new Uri(baseAddress);
    HttpResponseMessage response = await client.PutAsJsonAsync(serviceAddress + "/SaveActivationCode" + "?apiKey=445-65-1216", objAC);
} 

Et méthode de service comme celle-ci:

public HttpResponseMessage PutSaveActivationCode(ActivationCodes objAC)
{
}

PutAsJsonAsync s'occupe de la sérialisation et de la désérialisation sur le réseau