Come utilizzare System.Net.HttpClient per pubblicare un tipo complesso?

Ho un tipo complesso personalizzato con cui voglio lavorare usando l'API Web.

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

Ed ecco il mio metodo di controller API web. Voglio pubblicare questo oggetto in questo modo:

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

E ora vorrei utilizzare System.Net.HttpClientper effettuare la chiamata al metodo. Tuttavia, non sono sicuro di quale tipo di oggetto passare nel PostAsyncmetodo e come costruirlo. Ecco alcuni esempi di codice 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();
    });

Come faccio a creare l' HttpContentoggetto in modo che l'API web lo comprenda?

Il generico HttpRequestMessage<T>è stato rimosso . Questo :

new HttpRequestMessage<Widget>(widget)

sarà non funzionano più .

Invece, da questo post , il team ASP.NET ha incluso alcune nuove chiamate per supportare questa funzionalità:

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

Quindi, il nuovo codice ( da dunston ) diventa:

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

Dovresti SendAsyncinvece usare il metodo, questo è un metodo generico, che serializza l'input al servizio

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

Se non vuoi creare la classe concreta, puoi farlo con 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();
    });

Nota: devi rendere il tuo id un int ( int?) nullable

Tieni presente che se stai usando una libreria di classi portabile, HttpClient non avrà il metodo PostAsJsonAsync . Per pubblicare un contenuto come JSON usando una libreria di classi portabile, dovrai fare questo:

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

Se vuoi i tipi di metodi di convenienza menzionati in altre risposte ma hai bisogno della portabilità (o anche se non lo fai), potresti voler controllare Flurl [divulgazione: sono l'autore]. Avvolge (sottilmente) HttpCliente Json.NET e aggiunge un po 'di zucchero fluente e altre prelibatezze, inclusi alcuni aiutanti di test integrati .

Pubblica come JSON:

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

o con codifica URL:

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

Entrambi gli esempi sopra restituiscono un HttpResponseMessage, ma Flurl include metodi di estensione per restituire altre cose se vuoi solo andare al sodo:

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

Flurl è disponibile su NuGet:

PM> Install-Package Flurl.Http

Dopo aver esaminato molte alternative, mi sono imbattuto in un altro approccio, adatto alla versione API 2.0.

(VB.NET è il mio preferito, quindi ...)

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

In bocca al lupo! Per me questo ha funzionato (alla fine!).

Saluti, Peter

Penso che tu possa farlo:

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

Nel caso in cui qualcuno come me non avesse davvero capito di cosa si parla sopra, do un semplice esempio che funziona per me. Se si dispone di un'API Web il cui URL è " http://somesite.com/verifyAddress ", è un metodo di pubblicazione e richiede che gli venga passato un oggetto indirizzo. Vuoi chiamare questa API nel tuo codice. Ecco cosa puoi fare.

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

Questo è il codice con cui sono finito, basato sulle altre risposte qui. Questo è per un HttpPost che riceve e risponde con tipi complessi:

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

Effettua una chiamata di servizio come questa:

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

E il metodo di servizio come questo:

public HttpResponseMessage PutSaveActivationCode(ActivationCodes objAC)
{
}

PutAsJsonAsync si occupa della serializzazione e deserializzazione sulla rete