it-swarm.com.de

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

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

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

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;
93
Jammin

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

Eine andere wirklich einfache Lösung ist die Verwendung der Bibliothek Newtonsoft.Json:

User user = JsonConvert.DeserializeObject<User>(jsonString);
38
Daniel

Die folgenden 2 Beispiele verwenden beide

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

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!

32
user677607
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 .

7
Syam Developer

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.

5
Ioannis Suarez

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/

2
akazemis

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.

1
Sky Sanders

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

Der JSON C # -Klassengenerator im Codeplex generiert Klassen, die gut mit NewtonSoftJS zusammenarbeiten.

1
ΩmegaMan

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.