Jak przekonwertować obiekt JSON na niestandardowy obiekt C #?

Czy istnieje prosty sposób na wypełnienie mojego obiektu C # obiektem JSON przekazanym przez AJAX?

Jest to obiekt JSON przekazany do C # WEBMETHOD ze strony przy użyciu JSON.stringify

{
    "user": {
        "name": "asdf",
        "teamname": "b",
        "email": "c",
        "players": ["1", "2"]
    }
}

C # WebMetod, który odbiera obiekt JSON

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

}

Klasa C # reprezentująca strukturę obiektową obiektu JSON przekazanego do WebMethod

public class User
{
    public string name { get; set; }
    public string teamname { get; set; }
    public string email { get; set; }
    public Array players { get; set; }
}

Dobrym sposobem na użycie JSON w C # jest JSON.NET

Szybki start i dokumentacja API z JSON.NET - oficjalna strona pomaga w pracy z nim.

Przykład, jak z niego korzystać:

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

Ponieważ wszyscy kochamy jeden kod liniowy

Newtonsoft jest szybszy niż serializator skryptów Java. ... ten zależy od pakietu Newtonsoft NuGet, który jest popularny i lepszy niż domyślny serializator.

jeśli mamy klasę, użyj poniżej.

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

żadna klasa nie używa dynamiki

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

Aby pozostawić otwarte opcje, jeśli korzystasz z .NET 3.5 lub nowszego, oto zawarty przykład, którego możesz użyć bezpośrednio z frameworka za pomocą Generics. Jak wspomnieli inni, jeśli nie są to tylko proste obiekty, naprawdę powinieneś używać JSON.net.

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

Będziesz potrzebował:

using System.Runtime.Serialization;

using System.Runtime.Serialization.Json;

Biorąc pod uwagę przykładowy kod, nie powinieneś robić nic więcej.

Jeśli przekażesz ten ciąg JSON do metody internetowej, automatycznie przeanalizuje on ciąg JSON i utworzy zapełniony obiekt użytkownika jako parametr dla metody SaveTeam.

Ogólnie jednak możesz użyć tej JavascriptSerializerklasy, jak poniżej, lub dla większej elastyczności, użyć dowolnego z dostępnych frameworków Json (Jayrock JSON jest dobry) dla łatwej manipulacji JSON.

 JavaScriptSerializer jss= new JavaScriptSerializer();
 User user = jss.Deserialize<User>(jsonResponse); 

Innym naprawdę prostym rozwiązaniem jest użycie biblioteki Newtonsoft.Json:

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

Poniższe 2 przykłady wykorzystują oba

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

Przykład 1: użycie 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
        }
    }
}

Zastosowanie: Obiekt JSON na niestandardowy obiekt C #

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

Przykład 2: użycie 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
        }
    }
}

Zastosowanie: Obiekt JSON na niestandardowy obiekt C #

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

Ten kod wymaga dodania przestrzeni nazw System.Web.Helpers w,

% ProgramFiles% \ Microsoft ASP.NET \ ASP.NET Web Pages {VERSION} \ Assemblies \ System.Web.Helpers.dll

Lub

% ProgramFiles (x86)% \ Microsoft ASP.NET \ ASP.NET Web Pages {VERSION} \ Assemblies \ System.Web.Helpers.dll

Mam nadzieję że to pomoże!

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

Więcej informacji można znaleźć pod następującym linkiem http://ishareidea.blogspot.in/2012/05/json-conversion.html

O DataContractJsonSerializer Classtym możesz przeczytać tutaj .

Korzystanie z JavaScriptSerializer () jest mniej rygorystyczne niż oferowane ogólne rozwiązanie: public static T Deserialize (string json)

Może się to przydać przy przekazywaniu jsona na serwer, który nie odpowiada dokładnie definicji obiektu, na którą próbujesz przekonwertować.

Pod względem wydajności znalazłem serializator ServiceStack nieco szybciej niż inne. To klasa JsonSerializer w przestrzeni nazw ServiceStack.Text.

https://github.com/ServiceStack/ServiceStack.Text

ServiceStack jest dostępny za pośrednictwem pakietu NuGet: https://www.nuget.org/packages/ServiceStack/

JSON.Net jest najlepszym rozwiązaniem, ale w zależności od kształtu obiektów i zależności między kołami można użyć JavaScriptSerializer lub DataContractSerializer.

JSON C # klasa generator na CodePlex generuje klas, które działają dobrze z NewtonSoftJS.

JavaScript Serializer: wymaga 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);
    }
}

Serializer kontraktu danych: wymaga using System.Runtime.Serialization.Json; - Ogólny typ T powinien być możliwy do serializacji w większym stopniu na kontrakcie danych

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

Zamiast wysyłać jako przedmiot.

Utwórz publiczną klasę właściwości, która jest dostępna, i wyślij dane do metody internetowej.

[WebMethod]
public static void SaveTeam(useSomeClassHere user)
{
}

użyj tych samych nazw parametrów w wywołaniu ajax, aby wysłać dane.