Comment publier JSON d'un serveur à l'aide de C#?

Ademar de la solution peut être améliorée par l'optimisation des JavaScriptSerializer's Serialize méthode pour fournir la conversion implicite de l'objet JSON.

En outre, il est possible de tirer parti de la using déclaration de la fonctionnalité par défaut afin d'omettre appelant 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()))
{
    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();
}

Plus à Sean post, il n'est pas nécessaire de nid à l'aide de relevés. Par using le StreamWriter il sera vidé et fermé à la fin du bloc, donc pas besoin d'appeler explicitement la Flush() et Close() méthodes:

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 avez besoin d'appeler de manière asynchrone puis 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;
        }

    }

Cette option n'est pas mentionné:

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

J'ai finalement invoqué en mode de synchronisation, y compris par la .Résultat

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

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

.NET web existants les clients ne sont pas développeur sympathique! WebRequest & WebClient sont d'excellents exemples de "comment déjouer un développeur". Ils sont prolixes & compliqué de travailler avec; quand tout ce que vous voulez faire, c'est une simple requête Post en C#. HttpClient va d'une certaine manière dans la résolution de ces problèmes, mais il est encore loin. Sur le dessus de la documentation de Microsoft est mal ... vraiment mal; sauf si vous voulez parcourir des pages et des pages de techniques de blurb.

Open-source à la rescousse. Il y a trois excellents open-source, gratuit NuGet les bibliothèques comme des alternatives. Dieu merci! Ces sont tous bien pris en charge, documenté et oui, facile de correction...super facile à travailler avec.

• ServiceStack.Texte - rapide, léger et résistant.
• RestSharp - REPOS simple et API HTTP Client
• Flurl- couramment, portable, testable client HTTP bibliothèque

Il n'y a pas beaucoup d'entre eux, mais je donnerais ServiceStack.Texte le léger avantage ...

• Github étoiles sont à peu près les mêmes.
• Questions ouvertes & surtout comment rapidement tous vos problèmes de fermeture? ServiceStack prend le prix ici de la manière la plus rapide de résolution des problèmes, & pas de questions ouvertes.
• Documentation? Tous ont une grande documentation; toutefois, ServiceStack qu'il faut pour le niveau suivant & est connu pour son "Golden standard" pour la documentation.

Ok - donc, ce n'est une Requête Post en JSON ressembler au sein de ServiceStack.Texte?

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

Qui est une ligne de code. Concis & facile! Comparer ci-dessus pour .NET Http bibliothèques.