Hier ist der Code, den ich benutze:
// 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?
So mache und arbeite ich:
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 auf einfachere Weise auszuführen. Sie finden sie hier: https://github.com/ademargomes/JsonRequest
Ich hoffe es hilft.
Die Lösung von Ademar kann verbessert werden, indem die Methode JavaScriptSerializer
von Serialize
verwendet wird, um eine implizite Konvertierung des Objekts in JSON zu ermöglichen.
Darüber hinaus ist es möglich, die Standardfunktionalität der Anweisung using
zu nutzen, um das explizite Aufrufen von Flush
und Close
zu vermeiden.
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 Typ HttpClient
ist eine neuere Implementierung als der Typ WebClient
und 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 Ihr HttpClient
mehr als einmal benötigen, wird empfohlen, nur eine Instanz zu erstellen und diese wiederzuverwenden oder das neue HttpClientFactory
zu verwenden.
Zusätzlich zu Seans Beitrag ist es nicht erforderlich, die using-Anweisungen zu verschachteln. Durch using
den StreamWriter wird es am Ende des Blocks gelöscht und geschlossen, so dass die Methoden Flush()
und Close()
nicht explizit aufgerufen 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();
}
Achten Sie auf den von Ihnen verwendeten Content-Typ:
application/json
Quellen:
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;
}
}
Ich habe mir kürzlich eine viel einfachere Möglichkeit ausgedacht, einen JSON-Code zu veröffentlichen, mit dem zusätzlichen Schritt, ein 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;
}
}
Ich habe schließlich im Synchronisationsmodus durch Einfügen des . Result aufgerufen
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