Comment convertir objet JSON en Custom C# object?

puisque nous aimons tous un liners code

Newtonsoft est plus rapide que Java script serializer. ... celui-ci dépend du paquet NuGet Newtonsoft, qui est populaire et meilleur que le serializer par défaut.

si nous avons la classe alors utiliser ci-dessous.

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

aucune classe puis utilisez dynamique

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

pour garder vos options ouvertes, si vous utilisez .NET 3.5 ou plus tard, voici un exemple que vous pouvez utiliser directement depuis le framework en utilisant Generics. Comme d'autres l'ont mentionné, si ce n'est pas seulement des objets simples, vous devriez vraiment utiliser 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;
}

Vous aurez besoin de:

using System.Runtime.Serialization;

using System.Runtime.Serialization.Json;

étant donné votre exemple de code, vous ne devriez pas avoir à faire autre chose.

si vous passez cette chaîne JSON à votre méthode web, elle analysera automatiquement la chaîne JSON et créera un objet utilisateur peuplé comme paramètre pour votre méthode SaveTeam.

en général, vous pouvez utiliser la classe JavascriptSerializer comme ci-dessous, ou pour plus de flexibilité, utiliser l'un des différents cadres Json là-bas (Jayrock JSON est un bon) pour facile JSON manipulation.

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

une autre Solution très simple est D'utiliser la bibliothèque Newtonsoft.Json:

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

les deux exemples suivants utilisent l'un ou l'autre

1. JavaScriptSerializer sous système.Web.Script.Sérialisation Ou
2. Json.Décoder sous le système .Web.Helpers

exemple 1: en utilisant le système.Web.Script.La sérialisation

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

Utilisation: objet JSON à la Coutume objet 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; }
    }
}

exemple 2: en utilisant le système.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
        }
    }
}

Utilisation: objet JSON à la Coutume objet 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; }
    }
}

ce code nécessite l'ajout d'un système.Web.Les aides de l'espace de noms trouvés dans la,

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

ou

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

Espérons que cette aide!

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

plus d'informations allez au lien suivant http://ishareidea.blogspot.in/2012/05/json-conversion.html

à propos de DataContractJsonSerializer Class vous pouvez lire ici .

utilisant JavaScriptSerializer () est moins strict que la solution générique offerte : public static t Deserialize (string json)

qui pourrait s'avérer pratique en passant json au serveur qui ne correspond pas exactement à la définition D'objet vers laquelle vous essayez de convertir.

du point de vue des performances, j'ai trouvé le serializer de la sacoche un peu plus rapidement que les autres. C'est la classe JsonSerializer de ServiceStack.Texte de l'espace de noms.

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

ServiceStack est disponible via le paquet NuGet: https://www.nuget.org/packages/ServiceStack /

JSON.Net est votre meilleur pari mais, selon la forme des objets et s'il y a des dépendances circulaires, vous pouvez utiliser JavaScriptSerializer ou DataContractSerializer.

le générateur de classe JSON C# sur codeplex génère des classes qui fonctionnent bien avec NewtonSoftJS.

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

Contrat de Données Sérialiseur: nécessite using System.Runtime.Serialization.Json; - Le type générique T devrait être sérialisable plus sur le contrat de données

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

plutôt que d'envoyer un simple objet .

Créer une classe de propriétés qui est accessible et envoyer les données à l'Webmethod.

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

utilisez les mêmes noms de paramètres dans l'appel ajax pour envoyer des données.