Wie konvertiere ich ein JSON-Objekt in ein benutzerdefiniertes C # -Objekt?

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 empfängt das JSON-Objekt

[WebMethod]
public static void SaveTeam(Object user)
{

}

C # -Klasse, die die Objektstruktur des an die WebMethod übergebenen JSON-Objekts 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

Schnellstarts und API-Dokumentation von JSON.NET - Die offizielle Website hilft Ihnen dabei.

Ein Beispiel für die Verwendung:

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 One-Liner-Code lieben

Newtonsoft ist schneller als der Java Script Serializer. ... dies hängt vom Newtonsoft NuGet-Paket ab, das beliebt und besser als der Standard-Serializer ist.

Wenn wir Klasse haben, verwenden Sie unten.

Mycustomclassname oMycustomclassname = Newtonsoft.Json.JsonConvert.DeserializeObject<Mycustomclassname>(jsonString);

Keine Klasse verwendet dann dynamisch

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 heraus verwenden können. Wie andere bereits erwähnt haben, 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 anderes tun müssen.

Wenn Sie diese JSON-Zeichenfolge an Ihre Webmethode übergeben, wird die JSON-Zeichenfolge automatisch analysiert und ein aufgefülltes Benutzerobjekt als Parameter für Ihre SaveTeam-Methode erstellt.

Im Allgemeinen können Sie die JavascriptSerializerKlasse wie folgt verwenden oder für mehr Flexibilität eines der verschiedenen Json-Frameworks (Jayrock JSON ist gut) für eine einfache JSON-Manipulation verwenden.

 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 entweder

1. JavaScriptSerializer unter System.Web.Script.Serialization Or. En
2. Json.Decode unter System.Web.Helpers

Beispiel 1: Verwenden von 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
        }
    }
}

Verwendung: 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: Verwenden von 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
        }
    }
}

Verwendung: 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 Sie können hier lesen .

Die Verwendung von JavaScriptSerializer () ist weniger streng als die 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. Es 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, aber je nach Form der Objekte und ob es kreisförmige Abhängigkeiten gibt, können Sie JavaScriptSerializer oder DataContractSerializer verwenden.

Der JSON C # -Klassengenerator in Codeplex generiert Klassen, die mit NewtonSoftJS gut funktionieren.

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 im Data Contract besser serialisierbar sein

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

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 im Ajax-Aufruf dieselben Parameternamen, um Daten zu senden.