Comment publier JSON sur un serveur en utilisant C #?

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 string 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();
string result;
using (StreamReader rdr = new StreamReader(response.GetResponseStream()))
{
    result = rdr.ReadToEnd();
}

return result;

Lorsque j'exécute cela, j'obtiens toujours 500 erreurs de serveur interne.

Qu'est-ce que je fais mal?

La façon dont je le fais et fonctionne est:

var httpWebRequest = (HttpWebRequest)WebRequest.Create("http://url");
httpWebRequest.ContentType = "application/json";
httpWebRequest.Method = "POST";

using (var streamWriter = new StreamWriter(httpWebRequest.GetRequestStream()))
{
    string json = "{\"user\":\"test\"," +
                  "\"password\":\"bla\"}";

    streamWriter.Write(json);
}

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 ça aide.

La solution d'Ademar peut être améliorée en exploitant JavaScriptSerializerla Serializeméthode de pour fournir une conversion implicite de l'objet en JSON.

De plus, il est possible de tirer parti des usingfonctionnalités par défaut de l' instruction afin d'omettre explicitement d'appeler Flushet Close.

var httpWebRequest = (HttpWebRequest)WebRequest.Create("http://url");
httpWebRequest.ContentType = "application/json";
httpWebRequest.Method = "POST";

using (var streamWriter = new StreamWriter(httpWebRequest.GetRequestStream()))
{
    string 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();
}

Le HttpClienttype est une implémentation plus récente que le WebClientet HttpWebRequest.

Vous pouvez simplement utiliser les lignes suivantes.

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

Lorsque vous avez besoin de HttpClientplusieurs fois, il est recommandé de ne créer qu'une seule instance et de la réutiliser ou d'utiliser la nouvelle HttpClientFactory.

Suite à la publication de Sean, il n'est pas nécessaire d'imbriquer les instructions using. Par usingStreamWriter, il sera vidé et fermé à la fin du bloc, donc pas besoin 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()))
{
    string 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();
}

Si vous devez appeler de manière asynchrone, 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
        string postData = JsonConvert.SerializeObject(edit).ToString();

        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()))
        {
            string result = httpWebStreamReader.ReadToEnd();
            stat.Text = result;
        }

    }

Prenez soin du type de contenu que vous utilisez:

application/json

Sources :

RFC4627

Autre poste

J'ai récemment trouvé un moyen beaucoup plus simple de publier un JSON, avec l'étape supplémentaire de conversion à partir d'un modèle dans mon application. Notez que vous devez créer le modèle [JsonObject] pour que votre contrôleur obtienne les valeurs et effectue la conversion.

Demande:

 var model = new MyModel(); 

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

Modèle:

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

Du côté serveur:

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

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 façon différente et propre d'y parvenir est d'utiliser HttpClient comme ceci:

public async Task<HttpResponseMessage> PostResult(string 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;
     }
}

AVERTISSEMENT! J'ai une opinion très forte sur ce sujet.

Les clients Web existants de .NET ne sont pas adaptés aux développeurs! WebRequest et WebClient sont des exemples de "comment frustrer un développeur". Ils sont verbeux et compliqués à travailler; quand tout ce que vous voulez faire est une simple demande de publication en C #. HttpClient va dans une certaine mesure pour résoudre ces problèmes, mais il est toujours . En plus de cela, la documentation de Microsoft est mauvaise… vraiment mauvaise; sauf si vous souhaitez parcourir les pages et les pages de texte technique.

Open-source à la rescousse. Il existe trois excellentes bibliothèques NuGet libres et open source comme alternatives. Dieu merci! Tout cela est bien pris en charge, documenté et oui, facile - correction… super facile - avec lequel travailler.

• ServiceStack.Text - rapide, léger et résistant.
• RestSharp - Client API REST et HTTP simple
• Flurl - une bibliothèque client HTTP fluide, portable et testable

Il n'y a pas grand-chose entre eux, mais je donnerais à ServiceStack.Text le léger avantage…

• Les étoiles Github sont à peu près les mêmes.
• Problèmes ouverts et, surtout, à quelle vitesse les problèmes ont-ils été fermés? ServiceStack remporte le prix ici pour la résolution de problème la plus rapide et aucun problème ouvert.
• Documentation? Tous ont une excellente documentation; cependant, ServiceStack le porte au niveau supérieur et est connu pour son «standard d'or» pour la documentation.

Ok - alors à quoi ressemble une demande de publication dans JSON dans ServiceStack.Text?

var response = "http://example.org/login"
    .PostJsonToUrl(new Login { Username="admin", Password="mypassword" });

C'est une ligne de code. Concis et facile! Comparez ce qui précède aux bibliothèques Http de .NET.

J'ai finalement invoqué en mode sync en incluant le .Result

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

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

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

Utilisez ASCII au lieu de UFT8