¿Cómo publicar JSON en un servidor usando C #?

Aquí está el código que estoy 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;

Cuando ejecuto esto, siempre recibo 500 errores internos del servidor.

¿Qué estoy haciendo mal?

La forma en que lo hago y funciona es:

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

Escribí una biblioteca para realizar esta tarea de una manera más simple, está aquí: https://github.com/ademargomes/JsonRequest

Espero eso ayude.

La solución de Ademar se puede mejorar aprovechando JavaScriptSerializerel Serializemétodo para proporcionar la conversión implícita del objeto a JSON.

Además, es posible aprovechar la usingfuncionalidad predeterminada de la declaración para omitir llamar explícitamente Flushy 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();
}

El HttpClienttipo es una implementación más nueva que laWebClient y HttpWebRequest.

Simplemente puede usar las siguientes líneas.

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

Cuando necesite su HttpClientmás de una vez, se recomienda crear solo una instancia y reutilizarla o usar la nueva HttpClientFactory.

Además de la publicación de Sean, no es necesario anidar las declaraciones de uso. Por usingel StreamWriter que se vaciará y cerrado en el extremo del bloque así que no hay necesidad de explícitamente llamar al Flush()y Close()métodos:

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 necesita llamar de forma asíncrona, use

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

    }

Cuide el tipo de contenido que está utilizando:

application/json

Fuentes:

RFC4627

Otra publicación

Recientemente se me ocurrió una forma mucho más simple de publicar un JSON, con el paso adicional de convertir de un modelo en mi aplicación. Tenga en cuenta que debe crear el modelo [JsonObject] para que su controlador obtenga los valores y realice la conversión.

Solicitud:

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

Modelo:

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

Lado del servidor:

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

Esta opción no se menciona:

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

Una forma diferente y limpia de lograr esto es mediante el uso de HttpClient de esta manera:

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

¡ADVERTENCIA! Tengo una opinión muy fuerte sobre este tema.

¡Los clientes web existentes de .NET no son compatibles con los desarrolladores! WebRequest y WebClient son excelentes ejemplos de "cómo frustrar a un desarrollador". Son detallados y complicados para trabajar; cuando todo lo que quiere hacer es una simple solicitud de publicación en C #. HttpClient ayuda a resolver estos problemas, pero aún se queda corto. Además de eso, la documentación de Microsoft es mala ... realmente mala; a menos que quiera examinar páginas y páginas de publicidad técnica.

De código abierto al rescate. Hay tres excelentes bibliotecas NuGet gratuitas de código abierto como alternativas. ¡Gracias a dios! Todos estos están bien soportados, documentados y sí, fáciles de corregir ... súper fáciles de trabajar.

• ServiceStack.Text : rápido, ligero y resistente.
• RestSharp - Cliente REST simple y API HTTP
• Flurl : una biblioteca de cliente HTTP fluida, portátil y comprobable

No hay mucho entre ellos, pero le daría a ServiceStack.Text una ligera ventaja ...

• Las estrellas de Github son más o menos lo mismo.
• Problemas abiertos y, lo que es más importante, ¿con qué rapidez se cerraron los problemas? ServiceStack recibe el premio aquí por la resolución de problemas más rápida y sin problemas abiertos.
• ¿Documentación? Todos tienen excelente documentación; sin embargo, ServiceStack lo lleva al siguiente nivel y es conocido por su 'estándar de oro' para la documentación.

Ok, entonces, ¿cómo se ve una solicitud de publicación en JSON dentro de ServiceStack.Text?

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

Esa es una línea de código. Conciso y fácil! Compare lo anterior con las bibliotecas Http de .NET.

Finalmente invoqué en modo de sincronización incluyendo el .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);

Use ASCII en lugar de UFT8