Wie poste ich JSON mit C # auf einem Server?

Hier ist der Code, den ich verwende:

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

Wenn ich dies ausführe, erhalte ich immer 500 interne Serverfehler.

Was mache ich falsch?

Ich mache es so und arbeite wie folgt:

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

Ich habe eine Bibliothek geschrieben, um diese Aufgabe einfacher auszuführen. Sie ist hier: https://github.com/ademargomes/JsonRequest

Ich hoffe es hilft.

Ademar-Lösung kann durch den Einsatz verbessert werden JavaScriptSerializer‚sSerialize Verfahren implizite Konvertierung des Objekts zu JSON bereitzustellen.

Darüber hinaus ist es möglich, die usingStandardfunktionalität der Anweisung zu nutzen, um das explizite Aufrufen von Flushund zu vermeiden 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();
}

Der HttpClientTyp ist eine neuere Implementierung als das WebClientund HttpWebRequest.

Sie können einfach die folgenden Zeilen verwenden.

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

Wenn Sie Ihre HttpClientmehr als einmal benötigen , wird empfohlen, nur eine Instanz zu erstellen und wiederzuverwenden oder die neue zu verwenden HttpClientFactory.

Neben Seans Beitrag ist es nicht erforderlich, die using-Anweisungen zu verschachteln. Durch usingden StreamWriter wird er am Ende des Blocks geleert und geschlossen, sodass die Methoden Flush()und nicht explizit aufgerufen Close()werden müssen:

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

Wenn Sie asynchron anrufen müssen, verwenden Sie

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

    }

Achten Sie auf den von Ihnen verwendeten Inhaltstyp:

application/json

Quellen:

RFC4627

Anderer Beitrag

Ich habe mir kürzlich eine viel einfachere Möglichkeit ausgedacht, einen JSON zu veröffentlichen, mit dem zusätzlichen Schritt, von einem Modell in meiner App zu konvertieren. Beachten Sie, dass Sie das Modell [JsonObject] für Ihren Controller erstellen müssen, um die Werte abzurufen und die Konvertierung durchzuführen.

Anfrage:

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

Modell:

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

Serverseite:

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

Diese Option wird nicht erwähnt:

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

Eine andere und saubere Möglichkeit, dies zu erreichen, ist die Verwendung von HttpClient wie folgt:

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

WARNUNG! Ich habe eine sehr starke Meinung zu diesem Thema.

Die vorhandenen Web-Clients von .NET sind nicht entwicklerfreundlich! WebRequest & WebClient sind erstklassige Beispiele dafür, wie man einen Entwickler frustriert. Sie sind ausführlich und kompliziert zu bearbeiten; Wenn Sie nur eine einfache Post-Anfrage in C # senden möchten. HttpClient behebt diese Probleme in gewisser Weise, ist aber immer noch unzureichend. Darüber hinaus ist die Dokumentation von Microsoft schlecht… wirklich schlecht; es sei denn, Sie möchten Seiten und Seiten mit technischem Klappentext durchsuchen.

Open Source zur Rettung. Es gibt drei ausgezeichnete kostenlose Open-Source-NuGet-Bibliotheken als Alternativen. Gott sei Dank! Diese sind alle gut unterstützt, dokumentiert und ja, einfach zu korrigieren ... super einfach zu bearbeiten.

• ServiceStack.Text - schnell, leicht und belastbar.
• RestSharp - einfacher REST- und HTTP-API-Client
• Flurl - eine fließende, tragbare, testbare HTTP-Client-Bibliothek

Es gibt nicht viel zwischen ihnen, aber ich würde ServiceStack.Text die leichte Kante geben ...

• Github-Sterne sind ungefähr gleich.
• Offene Probleme und vor allem, wie schnell Probleme behoben wurden? ServiceStack erhält hier die Auszeichnung für die schnellste Problemlösung und keine offenen Probleme.
• Dokumentation? Alle haben eine großartige Dokumentation; ServiceStack bringt es jedoch auf die nächste Stufe und ist bekannt für seinen "goldenen Standard" für die Dokumentation.

Ok - wie sieht eine Post-Anfrage in JSON in ServiceStack.Text aus?

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

Das ist eine Codezeile. Prägnant und einfach! Vergleichen Sie die obigen Informationen mit den HTTP-Bibliotheken von .NET.

Ich habe schließlich im Synchronisierungsmodus aufgerufen, indem ich das .Result eingefügt habe

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

Verwenden Sie ASCII anstelle von UFT8