Comment publier JSON sur le serveur?

Voici le code que j’utilise:

// create a request HttpWebRequest request = (HttpWebRequest) WebRequest.Create(url); request.KeepAlive = false; request.ProtocolVersion = HttpVersion.Version10; request.Method = "POST"; // turn our request ssortingng into a byte stream byte[] postBytes = Encoding.UTF8.GetBytes(json); // this is important - make sure you specify type this way request.ContentType = "application/json; charset=UTF-8"; request.Accept = "application/json"; request.ContentLength = postBytes.Length; request.CookieContainer = Cookies; request.UserAgent = currentUserAgent; Stream requestStream = request.GetRequestStream(); // now send it requestStream.Write(postBytes, 0, postBytes.Length); requestStream.Close(); // grab te response and print it out to the console along with the status code HttpWebResponse response = (HttpWebResponse)request.GetResponse(); ssortingng result; using (StreamReader rdr = new StreamReader(response.GetResponseStream())) { result = rdr.ReadToEnd(); } return result; 

Lorsque j’exécute cela, je reçois toujours 500 erreurs de serveur internes.

Qu’est-ce que je fais mal?

La façon dont je le fais et travaille est la suivante:

 var httpWebRequest = (HttpWebRequest)WebRequest.Create("http://url"); httpWebRequest.ContentType = "application/json"; httpWebRequest.Method = "POST"; using (var streamWriter = new StreamWriter(httpWebRequest.GetRequestStream())) { ssortingng json = "{\"user\":\"test\"," + "\"password\":\"bla\"}"; streamWriter.Write(json); streamWriter.Flush(); streamWriter.Close(); } var httpResponse = (HttpWebResponse)httpWebRequest.GetResponse(); using (var streamReader = new StreamReader(httpResponse.GetResponseStream())) { var result = streamReader.ReadToEnd(); } 

J’ai écrit une bibliothèque pour effectuer cette tâche de manière plus simple, c’est ici: https://github.com/ademargomes/JsonRequest

J’espère que cela aide.

La solution d’Ademar peut être améliorée en exploitant la méthode Serialize JavaScriptSerializer pour fournir une conversion implicite de l’object en JSON.

En outre, il est possible d’exploiter la fonctionnalité par défaut de l’instruction using afin d’omettre d’appeler explicitement Flush et Close .

 var httpWebRequest = (HttpWebRequest)WebRequest.Create("http://url"); httpWebRequest.ContentType = "application/json"; httpWebRequest.Method = "POST"; using (var streamWriter = new StreamWriter(httpWebRequest.GetRequestStream())) { ssortingng json = new JavaScriptSerializer().Serialize(new { user = "Foo", password = "Baz" }); streamWriter.Write(json); } var httpResponse = (HttpWebResponse)httpWebRequest.GetResponse(); using (var streamReader = new StreamReader(httpResponse.GetResponseStream())) { var result = streamReader.ReadToEnd(); } 

Suite au post de Sean, il n’est pas nécessaire d’imbriquer les instructions d’utilisation. En using StreamWriter, il sera vidé et fermé à la fin du bloc, il n’est donc pas nécessaire d’appeler explicitement les méthodes Flush() et Close() :

 var request = (HttpWebRequest)WebRequest.Create("http://url"); request.ContentType = "application/json"; request.Method = "POST"; using (var streamWriter = new StreamWriter(request.GetRequestStream())) { ssortingng json = new JavaScriptSerializer().Serialize(new { user = "Foo", password = "Baz" }); streamWriter.Write(json); } var response = (HttpWebResponse)request.GetResponse(); using (var streamReader = new StreamReader(response.GetResponseStream())) { var result = streamReader.ReadToEnd(); } 

Prenez soin du type de contenu que vous utilisez:

 application/json 

Sources :

RFC4627

Autre poste

Si vous devez appeler est asynchrone alors utilisez

 var request = HttpWebRequest.Create("http://www.maplegraphservices.com/tokkri/webservices/updateProfile.php?oldEmailID=" + App.currentUser.email) as HttpWebRequest; request.Method = "POST"; request.ContentType = "text/json"; request.BeginGetRequestStream(new AsyncCallback(GetRequestStreamCallback), request); private void GetRequestStreamCallback(IAsyncResult asynchronousResult) { HttpWebRequest request = (HttpWebRequest)asynchronousResult.AsyncState; // End the stream request operation Stream postStream = request.EndGetRequestStream(asynchronousResult); // Create the post data ssortingng postData = JsonConvert.SerializeObject(edit).ToSsortingng(); byte[] byteArray = Encoding.UTF8.GetBytes(postData); postStream.Write(byteArray, 0, byteArray.Length); postStream.Close(); //Start the web request request.BeginGetResponse(new AsyncCallback(GetResponceStreamCallback), request); } void GetResponceStreamCallback(IAsyncResult callbackResult) { HttpWebRequest request = (HttpWebRequest)callbackResult.AsyncState; HttpWebResponse response = (HttpWebResponse)request.EndGetResponse(callbackResult); using (StreamReader httpWebStreamReader = new StreamReader(response.GetResponseStream())) { ssortingng result = httpWebStreamReader.ReadToEnd(); stat.Text = result; } } 

J’ai récemment mis au point un moyen beaucoup plus simple de publier un JSON, avec l’étape supplémentaire consistant à convertir à partir d’un modèle dans mon application. Notez que vous devez créer le modèle [JsonObject] pour que votre contrôleur puisse obtenir les valeurs et effectuer la conversion.

Demande:

  var model = new MyModel(); using (var client = new HttpClient()) { var uri = new Uri("XXXXXXXXX"); var json = new JavaScriptSerializer().Serialize(model); var ssortingngContent = new SsortingngContent(json, Encoding.UTF8, "application/json"); var response = await Client.PutAsync(uri,ssortingngContent).Result; ... ... } 

Modèle:

 [JsonObject] [Serializable] public class MyModel { public Decimal Value { get; set; } public ssortingng Project { get; set; } public ssortingng FilePath { get; set; } public ssortingng FileName { get; set; } } 

Du côté serveur:

 [HttpPut] public async Task PutApi([FromBody]MyModel model) { ... ... } 

Le type HttpClient est une implémentation plus récente que WebClient et HttpWebRequest .

Vous pouvez simplement utiliser les lignes suivantes.

 ssortingng myJson = "{'Username': 'myusername','Password':'pass'}"; using (var client = new HttpClient()) { var response = await client.PostAsync( "http://yourUrl", new SsortingngContent(myJson, Encoding.UTF8, "application/json")); } 

entrer la description de l'image ici

Lorsque vous avez besoin de votre HttpClient plus d’une fois, il est recommandé de ne créer qu’une seule instance et de la réutiliser ou d’utiliser le nouveau HttpClientFactory.

Cette option n’est pas mentionnée:

 using (var client = new HttpClient()) { client.BaseAddress = new Uri("http://localhost:9000/"); client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")); var foo = new User { user = "Foo", password = "Baz" } await client.PostAsJsonAsync("users/add", foo); } 

Une manière différente et propre d’y parvenir est d’utiliser HttpClient comme ceci:

 public async Task PostResult(ssortingng url, ResultObject resultObject) { using (var client = new HttpClient()) { HttpResponseMessage response = new HttpResponseMessage(); try { response = await client.PostAsJsonAsync(url, resultObject); } catch (Exception ex) { throw ex } return response; } } 

var data = Encoding.ASCII.GetBytes(json);

byte[] postBytes = Encoding.UTF8.GetBytes(json);

Utilisez ASCII au lieu de UFT8

J’ai finalement appelé en mode synchro en incluant le .Result

 HttpResponseMessage response = null; try { using (var client = new HttpClient()) { response = client.PostAsync( "http://localhost:8000/....", new SsortingngContent(myJson,Encoding.UTF8,"application/json")).Result; if (response.IsSuccessStatusCode) { MessageBox.Show("OK"); } else { MessageBox.Show("NOK"); } } } catch (Exception ex) { MessageBox.Show("ERROR"); }