Gibt es eine einfache Möglichkeit, mein C # -Objekt mit dem über AJAX übergebenen JSON-Objekt zu füllen?
Dies ist das JSON-Objekt, das von der Seite mit JSON.stringify an C # WEBMETHOD übergeben wird
{
"user": {
"name": "asdf",
"teamname": "b",
"email": "c",
"players": ["1", "2"]
}
}
C # WebMetod, das das JSON-Objekt empfängt
[WebMethod]
public static void SaveTeam(Object user)
{
}
C # -Klasse, die die an die WebMethod übergebene Objektstruktur von JSON Object darstellt
public class User
{
public string name { get; set; }
public string teamname { get; set; }
public string email { get; set; }
public Array players { get; set; }
}
Eine gute Möglichkeit, JSON in C # zu verwenden, ist JSON.NET
Schnellstart- und API-Dokumentation von JSON.NET - Offizielle Website helfen Ihnen bei der Arbeit damit.
Ein Beispiel, wie man es benutzt:
public class User
{
public User(string json)
{
JObject jObject = JObject.Parse(json);
JToken jUser = jObject["user"];
name = (string) jUser["name"];
teamname = (string) jUser["teamname"];
email = (string) jUser["email"];
players = jUser["players"].ToArray();
}
public string name { get; set; }
public string teamname { get; set; }
public string email { get; set; }
public Array players { get; set; }
}
// Use
private void Run()
{
string json = @"{""user"":{""name"":""asdf"",""teamname"":""b"",""email"":""c"",""players"":[""1"",""2""]}}";
User user = new User(json);
Console.WriteLine("Name : " + user.name);
Console.WriteLine("Teamname : " + user.teamname);
Console.WriteLine("Email : " + user.email);
Console.WriteLine("Players:");
foreach (var player in user.players)
Console.WriteLine(player);
}
Da wir alle einen Liner Code lieben
Newtonsoft ist schneller als der Script-Serializer Java. ... dies hängt vom Newtonsoft NuGet-Paket ab, das populär und besser als der Standard-Serializer ist.
wenn wir klasse haben dann benutze unten.
Mycustomclassname oMycustomclassname = Newtonsoft.Json.JsonConvert.DeserializeObject<Mycustomclassname>(jsonString);
keine klasse dann benutze dynamic
var oMycustomclassname = Newtonsoft.Json.JsonConvert.DeserializeObject<dynamic>(jsonString);
Um Ihre Optionen offen zu halten, wenn Sie .NET 3.5 oder höher verwenden, finden Sie hier ein Beispiel, das Sie mit Generics direkt aus dem Framework verwenden können. Wie bereits erwähnt, sollten Sie JSON.net wirklich verwenden, wenn es sich nicht nur um einfache Objekte handelt.
public static string Serialize<T>(T obj)
{
DataContractJsonSerializer serializer = new DataContractJsonSerializer(obj.GetType());
MemoryStream ms = new MemoryStream();
serializer.WriteObject(ms, obj);
string retVal = Encoding.UTF8.GetString(ms.ToArray());
return retVal;
}
public static T Deserialize<T>(string json)
{
T obj = Activator.CreateInstance<T>();
MemoryStream ms = new MemoryStream(Encoding.Unicode.GetBytes(json));
DataContractJsonSerializer serializer = new DataContractJsonSerializer(obj.GetType());
obj = (T)serializer.ReadObject(ms);
ms.Close();
return obj;
}
Du brauchst:
using System.Runtime.Serialization;
using System.Runtime.Serialization.Json;
In Anbetracht Ihres Codebeispiels sollten Sie nichts weiter tun müssen.
Wenn Sie diese JSON-Zeichenfolge an Ihre Webmethode übergeben, wird die JSON-Zeichenfolge automatisch analysiert und ein gefülltes Benutzerobjekt als Parameter für Ihre SaveTeam-Methode erstellt.
Im Allgemeinen können Sie die JavascriptSerializer
-Klasse wie folgt verwenden oder für mehr Flexibilität eines der verschiedenen Json-Frameworks verwenden (Jayrock JSON ist ein gutes Framework), um die JSON-Manipulation zu vereinfachen.
JavaScriptSerializer jss= new JavaScriptSerializer();
User user = jss.Deserialize<User>(jsonResponse);
Eine andere wirklich einfache Lösung ist die Verwendung der Bibliothek Newtonsoft.Json:
User user = JsonConvert.DeserializeObject<User>(jsonString);
Die folgenden 2 Beispiele verwenden beide
Beispiel 1: using System.Web.Script.Serialization
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Web.Script.Serialization;
namespace Tests
{
[TestClass]
public class JsonTests
{
[TestMethod]
public void Test()
{
var json = "{\"user\":{\"name\":\"asdf\",\"teamname\":\"b\",\"email\":\"c\",\"players\":[\"1\",\"2\"]}}";
JavaScriptSerializer serializer = new JavaScriptSerializer();
dynamic jsonObject = serializer.Deserialize<dynamic>(json);
dynamic x = jsonObject["user"]; // result is Dictionary<string,object> user with fields name, teamname, email and players with their values
x = jsonObject["user"]["name"]; // result is asdf
x = jsonObject["user"]["players"]; // result is object[] players with its values
}
}
}
sage: JSON-Objekt zu benutzerdefiniertem C # -Objekt
using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Web.Script.Serialization;
using System.Linq;
namespace Tests
{
[TestClass]
public class JsonTests
{
[TestMethod]
public void TestJavaScriptSerializer()
{
var json = "{\"user\":{\"name\":\"asdf\",\"teamname\":\"b\",\"email\":\"c\",\"players\":[\"1\",\"2\"]}}";
User user = new User(json);
Console.WriteLine("Name : " + user.name);
Console.WriteLine("Teamname : " + user.teamname);
Console.WriteLine("Email : " + user.email);
Console.WriteLine("Players:");
foreach (var player in user.players)
Console.WriteLine(player);
}
}
public class User {
public User(string json) {
JavaScriptSerializer serializer = new JavaScriptSerializer();
var jsonObject = serializer.Deserialize<dynamic>(json);
name = (string)jsonObject["user"]["name"];
teamname = (string)jsonObject["user"]["teamname"];
email = (string)jsonObject["user"]["email"];
players = jsonObject["user"]["players"];
}
public string name { get; set; }
public string teamname { get; set; }
public string email { get; set; }
public Array players { get; set; }
}
}
Beispiel 2: using System.Web.Helpers
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Web.Helpers;
namespace Tests
{
[TestClass]
public class JsonTests
{
[TestMethod]
public void TestJsonDecode()
{
var json = "{\"user\":{\"name\":\"asdf\",\"teamname\":\"b\",\"email\":\"c\",\"players\":[\"1\",\"2\"]}}";
dynamic jsonObject = Json.Decode(json);
dynamic x = jsonObject.user; // result is dynamic json object user with fields name, teamname, email and players with their values
x = jsonObject.user.name; // result is asdf
x = jsonObject.user.players; // result is dynamic json array players with its values
}
}
}
sage: JSON-Objekt zu benutzerdefiniertem C # -Objekt
using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Web.Helpers;
using System.Linq;
namespace Tests
{
[TestClass]
public class JsonTests
{
[TestMethod]
public void TestJsonDecode()
{
var json = "{\"user\":{\"name\":\"asdf\",\"teamname\":\"b\",\"email\":\"c\",\"players\":[\"1\",\"2\"]}}";
User user = new User(json);
Console.WriteLine("Name : " + user.name);
Console.WriteLine("Teamname : " + user.teamname);
Console.WriteLine("Email : " + user.email);
Console.WriteLine("Players:");
foreach (var player in user.players)
Console.WriteLine(player);
}
}
public class User {
public User(string json) {
var jsonObject = Json.Decode(json);
name = (string)jsonObject.user.name;
teamname = (string)jsonObject.user.teamname;
email = (string)jsonObject.user.email;
players = (DynamicJsonArray) jsonObject.user.players;
}
public string name { get; set; }
public string teamname { get; set; }
public string email { get; set; }
public Array players { get; set; }
}
}
Dieser Code erfordert das Hinzufügen des System.Web.Helpers-Namespace in,
% ProgramFiles%\Microsoft ASP.NET\ASP.NET-Webseiten {VERSION}\Assemblies\System.Web.Helpers.dll
Oder
% ProgramFiles (x86)%\Microsoft ASP.NET\ASP.NET-Webseiten {VERSION}\Assemblies\System.Web.Helpers.dll
Hoffe das hilft!
public static class Utilities
{
public static T Deserialize<T>(string jsonString)
{
using (MemoryStream ms = new MemoryStream(Encoding.Unicode.GetBytes(jsonString)))
{
DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(T));
return (T)serializer.ReadObject(ms);
}
}
}
Weitere Informationen finden Sie unter folgendem Link http://ishareidea.blogspot.in/2012/05/json-conversion.html
Über DataContractJsonSerializer Class
können Sie lesen hier .
Die Verwendung von JavaScriptSerializer () ist weniger streng als die angebotene generische Lösung: public static T Deserialize (string json)
Dies kann nützlich sein, wenn Sie json an den Server übergeben, der nicht genau der Objektdefinition entspricht, in die Sie konvertieren möchten.
In Bezug auf die Leistung fand ich den Serializer des ServiceStack etwas schneller als andere. Dies ist die JsonSerializer-Klasse im ServiceStack.Text-Namespace.
https://github.com/ServiceStack/ServiceStack.Text
ServiceStack ist über das NuGet-Paket verfügbar: https://www.nuget.org/packages/ServiceStack/
JSON.Net ist die beste Wahl. Abhängig von der Form der Objekte und den kreisförmigen Abhängigkeiten können Sie jedoch JavaScriptSerializer oder DataContractSerializer verwenden.
JavaScript Serializer: erfordert using System.Web.Script.Serialization;
public class JavaScriptSerializerDeSerializer<T>
{
private readonly JavaScriptSerializer serializer;
public JavaScriptSerializerDeSerializer()
{
this.serializer = new JavaScriptSerializer();
}
public string Serialize(T t)
{
return this.serializer.Serialize(t);
}
public T Deseralize(string stringObject)
{
return this.serializer.Deserialize<T>(stringObject);
}
}
Data Contract Serializer: erfordert using System.Runtime.Serialization.Json;
- Der generische Typ T sollte serialisierbar sein mehr zu Data Contract
public class JsonSerializerDeserializer<T> where T : class
{
private readonly DataContractJsonSerializer jsonSerializer;
public JsonSerializerDeserializer()
{
this.jsonSerializer = new DataContractJsonSerializer(typeof(T));
}
public string Serialize(T t)
{
using (var memoryStream = new MemoryStream())
{
this.jsonSerializer.WriteObject(memoryStream, t);
memoryStream.Position = 0;
using (var sr = new StreamReader(memoryStream))
{
return sr.ReadToEnd();
}
}
}
public T Deserialize(string objectString)
{
using (var ms = new MemoryStream(System.Text.ASCIIEncoding.ASCII.GetBytes((objectString))))
{
return (T)this.jsonSerializer.ReadObject(ms);
}
}
}
Der JSON C # -Klassengenerator im Codeplex generiert Klassen, die gut mit NewtonSoftJS zusammenarbeiten.
Anstatt nur als Objekt zu senden.
Erstellen Sie eine öffentliche Klasse von Eigenschaften, auf die zugegriffen werden kann, und senden Sie die Daten an die Webmethode.
[WebMethod]
public static void SaveTeam(useSomeClassHere user)
{
}
verwenden Sie dieselben Parameternamen im Ajax-Aufruf, um Daten zu senden.