Come pubblicare JSON su un server utilizzando C #?

Ecco il codice che sto usando:

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

Quando lo eseguo, visualizzo sempre 500 errori del server interno.

Che cosa sto facendo di sbagliato?

Il modo in cui lo faccio e funziona è:

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

Ho scritto una libreria per eseguire questo compito in modo più semplice, è qui: https://github.com/ademargomes/JsonRequest

Spero che sia d'aiuto.

La soluzione di Ademar può essere migliorata sfruttando JavaScriptSerializeril Serializemetodo per fornire la conversione implicita dell'oggetto in JSON.

Inoltre, è possibile sfruttare la usingfunzionalità predefinita dell'istruzione per omettere esplicitamente la chiamata Flushe 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();
}

Il HttpClienttipo è un'implementazione più recente rispetto a WebCliente HttpWebRequest.

Puoi semplicemente usare le seguenti righe.

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

Quando è necessario HttpClientpiù di una volta, si consiglia di creare solo un'istanza e riutilizzarla o utilizzare la nuova HttpClientFactory.

Oltre al post di Sean, non è necessario nidificare le dichiarazioni using. Tramite usingStreamWriter verrà scaricato e chiuso alla fine del blocco, quindi non è necessario chiamare esplicitamente i metodi Flush()e 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();
}

Se è necessario chiamare in modo asincrono, utilizzare

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

    }

Prenditi cura del tipo di contenuto che stai utilizzando:

application/json

Fonti:

RFC4627

Altro post

Di recente ho trovato un modo molto più semplice di pubblicare un JSON, con l'ulteriore passaggio di conversione da un modello nella mia app. Nota che devi creare il modello [JsonObject] per il tuo controller per ottenere i valori ed eseguire la conversione.

Richiesta:

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

Modello:

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

Lato server:

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

Questa opzione non è menzionata:

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

Un modo diverso e pulito per raggiungere questo obiettivo è utilizzare HttpClient in questo modo:

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

AVVERTIMENTO! Ho una visione molto forte di questo argomento.

I client Web esistenti di .NET non sono adatti agli sviluppatori! WebRequest e WebClient sono ottimi esempi di "come frustrare uno sviluppatore". Sono prolissi e complicati con cui lavorare; quando tutto quello che vuoi fare è una semplice richiesta Pubblica in C #. HttpClient qualche modo a risolvere questi problemi, ma non è ancora . Inoltre la documentazione di Microsoft è pessima ... davvero pessima; a meno che non si desideri vagliare pagine e pagine di problemi tecnici.

Open-source in soccorso. Esistono tre eccellenti librerie NuGet open source e gratuite come alternative. Grazie a Dio! Questi sono tutti ben supportati, documentati e sì, facile - correzione ... super facile - con cui lavorare.

• ServiceStack.Text : veloce, leggero e resistente.
• RestSharp : client API REST e HTTP semplice
• Flurl : una libreria client HTTP fluida, portatile e testabile

Non c'è molto tra loro, ma darei ServiceStack.Text il leggero vantaggio ...

• Le stelle di Github sono all'incirca le stesse.
• Problemi aperti e, soprattutto, quanto velocemente eventuali problemi sono stati chiusi? ServiceStack riceve il premio qui per la risoluzione dei problemi più rapida e senza problemi aperti.
• Documentazione? Tutti hanno un'ottima documentazione; tuttavia, ServiceStack lo porta al livello successivo ed è noto per la sua "norma d'oro" per la documentazione.

Ok, quindi come appare una richiesta di post in JSON in ServiceStack.

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

Questa è una riga di codice. Conciso e facile! Confronta quanto sopra con le librerie Http di .NET.

Alla fine ho invocato in modalità di sincronizzazione includendo il .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);

Usa ASCII invece di UFT8