Jak wysłać JSON na serwer za pomocą C #?

Oto kod, którego używam:

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

Kiedy to uruchamiam, zawsze pojawia się 500 wewnętrzny błąd serwera.

Co ja robię źle?

Sposób, w jaki to robię i działa to:

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

Napisałem bibliotekę, aby wykonać to zadanie w prostszy sposób, jest tutaj: https://github.com/ademargomes/JsonRequest

Mam nadzieję, że to pomoże.

Roztwór Ademar może być poprawiona poprzez wykorzystanie JavaScriptSerializerjest Serializesposób zapewnić niejawnego konwersji obiektu JSON.

Dodatkowo można wykorzystać usingdomyślną funkcjonalność instrukcji, aby pominąć jawne wywołanie Flushi 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();
}

Ten HttpClienttyp jest nowszą implementacją niż WebClienti HttpWebRequest.

Możesz po prostu użyć następujących wierszy.

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

Jeśli potrzebujesz HttpClientwięcej niż raz, zaleca się utworzenie tylko jednego wystąpienia i ponowne użycie go lub użycie nowego HttpClientFactory.

Poza postem Seana nie trzeba zagnieżdżać instrukcji using. By usingw StreamWriter będzie zaczerwieniona i zamknięta na końcu bloku, więc nie trzeba jawnie wywołać Flush()i Close()metod:

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

Jeśli chcesz zadzwonić asynchronicznie, użyj

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

    }

Zadbaj o typ zawartości, którego używasz:

application/json

Źródła:

RFC4627

Inny post

Niedawno wymyśliłem znacznie prostszy sposób opublikowania JSON, z dodatkowym krokiem konwersji z modelu w mojej aplikacji. Pamiętaj, że musisz wykonać model [JsonObject] dla swojego kontrolera, aby uzyskać wartości i wykonać konwersję.

Żądanie:

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

Model:

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

Po stronie serwera:

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

Ta opcja nie jest wymieniona:

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

Innym i czystym sposobem na osiągnięcie tego jest użycie HttpClient w następujący sposób:

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

OSTRZEŻENIE! Mam bardzo mocne zdanie na ten temat.

Obecni klienci sieci .NET nie są przyjaźni dla programistów! WebRequest i WebClient są doskonałymi przykładami „jak sfrustrować programistę”. Są pełne i skomplikowane w pracy; gdy wszystko, co chcesz zrobić, to proste żądanie Post w C #. HttpClient w jakiś sposób rozwiązuje te problemy, ale nadal nie spełnia tego zadania . Poza tym dokumentacja Microsoftu jest zła… naprawdę zła; chyba że chcesz przeszukiwać strony techniczne.

Open-source na ratunek.Istnieją trzy doskonałe, bezpłatne biblioteki NuGet jako alternatywy. Dzięki Bogu! Wszystkie są dobrze obsługiwane, udokumentowane i tak, łatwa - korekta… bardzo łatwa - praca.

• ServiceStack.Text - szybki, lekki i odporny.
• RestSharp - prosty klient REST i HTTP API
• Flurl - płynna, przenośna, testowalna biblioteka klienta HTTP

Nie ma między nimi wiele, ale dałbym ServiceStack. Tekst lekką przewagę…

• Gwiazdy Github są mniej więcej takie same.
• Otwarte problemy i, co ważne, jak szybko jakieś problemy zostały zamknięte? ServiceStack odbiera nagrodę za najszybsze rozwiązanie problemu i brak otwartych problemów.
• Dokumentacja? Wszystkie mają świetną dokumentację; jednak ServiceStack przenosi go na wyższy poziom i jest znany ze swojego „złotego standardu” w zakresie dokumentacji.

Ok - więc jak wygląda żądanie postu w JSON w ServiceStack.Text?

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

To jest jedna linia kodu. Zwięzłe i łatwe! Porównaj powyższe z bibliotekami HTTP platformy .NET.

W końcu wywołałem w trybie synchronizacji, włączając .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);

Użyj ASCII zamiast UFT8