weixin_41568208
北城已荒凉
2010-02-11 18:30
采纳率: 0%
浏览 356

如何将 JSON 对象转换为自定义 c # 对象?

Is there an easy way to populate my C# Object with the JSON object passed via AJAX?

//This is the JSON Object passed to C# WEBMETHOD from the page using JSON.stringify

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

//C# WebMetod That receives the JSON Object

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

}

//C# Class that represents the object structure of JSON Object passed in to the WebMethod

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

转载于:https://stackoverflow.com/questions/2246694/how-to-convert-json-object-to-custom-c-sharp-object

  • 点赞
  • 写回答
  • 关注问题
  • 收藏
  • 邀请回答

13条回答 默认 最新

  • csdnceshi57
    perhaps? 2010-02-11 18:33
    已采纳

    A good way to use JSON in C# is with JSON.NET

    Quick Starts & API Documentation from JSON.NET - Official site help you work with it.

    An example of how to use it:

    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);
     }
    
    点赞 评论
  • csdnceshi63
    elliott.david 2010-02-11 18:38

    Given your code sample, you shouldn't need to do anything else.

    If you pass that JSON string to your web method, it will automatically parse the JSON string and create a populated User object as the parameter for your SaveTeam method.

    Generally though, you can use the JavascriptSerializer class as below, or for more flexibility, use any of the various Json frameworks out there (Jayrock JSON is a good one) for easy JSON manipulation.

     JavaScriptSerializer jss= new JavaScriptSerializer();
     User user = jss.Deserialize<User>(jsonResponse); 
    
    点赞 评论
  • weixin_41568126
    乱世@小熊 2010-02-11 18:38

    JSON.Net is your best bet but, depending on the shape of the objects and whether there are circular dependencies, you could use JavaScriptSerializer or DataContractSerializer.

    点赞 评论
  • weixin_41568184
    叼花硬汉 2010-02-11 18:39

    To keep your options open, if you're using .NET 3.5 or later, here is a wrapped up example you can use straight from the framework using Generics. As others have mentioned, if it's not just simple objects you should really use 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;
    }
    

    You'll need:

    using System.Runtime.Serialization;
    
    using System.Runtime.Serialization.Json;
    
    点赞 评论
  • csdnceshi74
    7*4 2011-12-14 17:56

    Using JavaScriptSerializer() is less strict than the generic solution offered : public static T Deserialize(string json)

    That might come handy when passing json to the server that does not match exactly the Object definition you are trying to convert to.

    点赞 评论
  • csdnceshi58
    Didn"t forge 2012-06-14 04:24
    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);
            }
        }
    }
    

    More information go to following link http://ishareidea.blogspot.in/2012/05/json-conversion.html

    About DataContractJsonSerializer Class you can read here.

    点赞 评论
  • csdnceshi56
    lrony* 2013-04-25 16:45

    The JSON C# class generator on codeplex generates classes which work well with NewtonSoftJS.

    点赞 评论
  • csdnceshi67
    bug^君 2013-10-03 18:45

    The following 2 examples make use of either

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

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

    Usage: JSON object to Custom C# object

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

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

    Usage: JSON object to Custom C# object

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

    This code requires adding System.Web.Helpers namespace found in,

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

    Or

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

    Hope this helps!

    点赞 评论
  • weixin_41568184
    叼花硬汉 2015-01-21 07:35

    Since we all love one liners code

    Newtonsoft is faster than java script serializer. ... this one depends on the Newtonsoft NuGet package, which is popular and better than the default serializer.

    if we have class then use below.

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

    no class then use dynamic

    var oMycustomclassname = Newtonsoft.Json.JsonConvert.DeserializeObject<dynamic>(Json Object);
    
    点赞 评论
  • csdnceshi53
    Lotus@ 2015-07-28 09:00

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

    Data Contract Serializer: requires using System.Runtime.Serialization.Json; - The generic type T should be serializable more on 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);
            }
        }
    }
    
    点赞 评论
  • weixin_41568184
    叼花硬汉 2015-08-19 22:29

    Another Really simple Solution is using the library Newtonsoft.Json:

    User user = JsonConvert.DeserializeObject<User>(jsonString);
    
    点赞 评论
  • csdnceshi66

    Performance-wise, I found the ServiceStack's serializer a bit faster than then others. It's JsonSerializer class in ServiceStack.Text namespace.

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

    ServiceStack is available through NuGet package: https://www.nuget.org/packages/ServiceStack/

    点赞 评论
  • csdnceshi76
    斗士狗 2017-10-20 11:30

    Rather than sending as just an object .

    Create a public class of properties that is accessible and send the data to the Webmethod.

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

    use same parameters names in ajax call to send data.

    点赞 评论

相关推荐