简单的JSON操作[俺等了几天了。。]

Question

如何将下述Json字符转List... [{"c":"理","d":[{"a":"数学","b":"上午"},{"a":"地理","b":"下午"}]},{"c":"文","d":[{"a":"历史","b":"下午"},{"a":"政治","b":"上午"}]}] 期待中，，，

Answer 1

JavaScriptSerializer serializer = new JavaScriptSerializer();
serializer.Deserialize<类名>("输入字符串");

Answer 2

引用这个命名空间 using System.Web.Script.Serialization

Answer 3

1 //
 2 // ObjectListToJSON
 3 // Copyright (c) 2008 pcode. All rights reserved.
 4 //
 5 //  Author(s):
 6 //
 7 //      pcode,[email protected]
 8 //  此类用于将List<object>转换为json数据格式
 9 //  目前仅能处理一个object的基础数据类型而且对[ { }] \等对json有伤害影响特殊符号没有特殊处理
10 //  希望有兄弟继续完善
11 
12 using System.Reflection;
13 using System.Collections.Generic;
14 
15 public class ObjectListToJSON
16 {
17     #region 反射一个对象所有属性和属性值和将一个对象的反射结果封装成jsons格式
18     /**
19          * 对象的全部属性和属性值。用于填写json的{}内数据
20          * 生成后的格式类似
21          * "属性1":"属性值"
22          * 将这些属性名和属性值写入字符串列表返回
23          * */
24     private List<string> GetObjectProperty(object o)
25     {
26         List<string> propertyslist = new List<string>();
27         PropertyInfo[] propertys = o.GetType().GetProperties();
28         foreach (PropertyInfo p in propertys)
29         {
30             propertyslist.Add("\"" + p.Name.ToString() + "\":\"" + p.GetValue(o, null) + "\"");
31         }
32         return propertyslist;
33     }
34     /**
35      * 将一个对象的所有属性和属性值按json的格式要求输入为一个封装后的结果。
36      *
37      * 返回值类似{"属性1":"属性1值","属性2":"属性2值","属性3":"属性3值"}
38      * 
39      * */
40     private string OneObjectToJSON(object o)
41     {
42         string result = "{";
43         List<string> ls_propertys = new List<string>();
44         ls_propertys = GetObjectProperty(o);
45         foreach (string str_property in ls_propertys)
46         {
47             if (result.Equals("{"))
48             {
49                 result = result + str_property;
50             }
51             else
52             {
53                 result = result + "," + str_property + "";
54             }
55         }
56         return result + "}";
57     }
58     #endregion
59     /**
60          * 把对象列表转换成json串
61          * */
62     public string toJSON(List<object> objlist)
63     {//覆写，给懒人一个不写classname的机会
64         return toJSON(objlist, string.Empty);
65     }
66     public string toJSON(List<object> objlist, string classname)
67     {
68         string result = "{";
69         if (classname.Equals(string.Empty))//如果没有给定类的名称，那么自做聪明地安一个
70         {
71             object o = objlist[0]
72             classname = o.GetType().ToString();
73         }
74         result += "\"" + classname + "\":[";
75         bool firstline = true;//处理第一行前面不加","号
76         foreach (object oo in objlist)
77         {
78             if (!firstline)
79             {
80                 result = result + "," + OneObjectToJSON(oo);
81             }
82             else
83             {
84                 result = result + OneObjectToJSON(oo) + "";
85                 firstline = false;
86             }
87         }
88         return result + "]}";
89     }
90 
91 }
92 
 OK，我们建立一个测试来验证一下它是否生效。先建立一个对象定义person.cs[http://www.cnblogs.com/Images/OutliningIndicators/ContractedBlock.gif 查看外站图片]
Code highlighting produced by Actipro CodeHighlighter (freeware)
http://www.CodeHighlighter.com/-->namespace Model
{
    public class Person
    {
        public string ID { get; set; }
        public string Name { get; set; }
        public string Sex { get; set; }
    }
}然后建立测试类我用了一种非常原始的方法生成了对象列表，其实可以从数据库查询，怕把事情搞得太复杂。呵呵。[http://www.cnblogs.com/Images/OutliningIndicators/ContractedBlock.gif 查看外站图片]
Code highlighting produced by Actipro CodeHighlighter (freeware)
http://www.CodeHighlighter.com/-->using NUnit.Framework;
using System.Collections.Generic;
namespace JSon
{
    [TestFixture]
    public class TestObjectToJSON
    {
        [Test]
        public void dotest() {
            Model.Person p1 = new Model.Person();
            p1.ID = "1";
            p1.Name = "p1";
            p1.Sex = "s1";
            Model.Person p2 = new Model.Person();
            p2.ID = "2";
            p2.Name = "p2";
            p2.Sex = "s2";            Model.Person p3 = new Model.Person();
            p3.ID = "3";
            p3.Name = "p3";
            p3.Sex = "s3";
            List<object> lp = new List<object>();
            lp.Add(p1);
            lp.Add(p2);
            lp.Add(p3);            ObjectListToJSON t = new ObjectListToJSON();
            string json = t.toJSON(lp, "persons");
            System.Console.Write(json);
        }
    }
}

Answer 4

哥们，就是问这个<类名>，，怎么得到呀如何创建相应的类？？？

Answer 5

引用josn.netJavaScriptObject jsobj = (JavaScriptObject)JavaScriptConvert.DeserializeObject(str);

Answer 6

引用 2 楼 watsonchia 的回复:
JavaScriptSerializer serializer = new JavaScriptSerializer(); 
serializer.Deserialize <类名>("输入字符串"); 哥们，就是问这个 <类名>，，怎么得到呀如何创建相应的类？？？

Answer 7

JavaScriptSerializer serializer = new JavaScriptSerializer();
            Dictionary<string, object> list = (Dictionary<string, object>)serializer.DeserializeObject(json);

Answer 8

newphp.php:
<?php
echo "[{\"c\":\"理\",\"d\":[{\"a\":\"数学\",\"b\":\"上午\"},{\"a\":\"地理\",\"b\":\"下午\"}]},{\"c\":\"文\",\"d\":[{\"a\":\"历史\",\"b\":\"下午\"},{\"a\":\"政治\",\"b\":\"上午\"}]}]";
?>
newhtml.html:<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <title></title>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <script src="Scripts/Jquery.js" type="text/javascript"></script>
    <script type="text/javascript">
        $.getJSON("newphp.php", function(data){
            var str = "<table border=\"1\" cellspacing=\"0\" cellpadding=\"0\">"
            for(var i=0;i<data.length;i++) {
                for(var j=0;j<data[i]["d"].length;j++) {
                    str += "<tr>";
                    if(j==0) {
                        str += "<td rowspan=\"" + data[i]["d"].length + "\">" + data[i]["c"] + "</td><td>" + data[i]["d"][j]["a"] + "</td><td>" + data[i]["d"][j]["b"] + "</td>";
                    } else {
                        str += "<td>" + data[i]["d"][j]["a"] + "</td><td>" + data[i]["d"][j]["b"] + "</td>";
                    }
                    str += "</tr>";
                }
            }
            str += "</table>";
            $("#testdiv").html(str);
        })
    </script>
  </head>
  <body>
      <div id="testdiv"></div>
  </body>
</html>结果：

Answer 9

汗看错题目了，，原来是.net的晕。。当成PHP了。

Answer 10

我手头暂时没有VS调试，，不过可以给你看看我以前写时用到的将JSON转成字符串输出的你按照我的JSON格式换成你的就可以了。。JSON数据格式：
[{"FilmName":"11111","FilmNum":"1111111"FilmPlay":"1"},{"FilmName":"222222","FilmNum":"2222222"FilmPlay":"1"},{"FilmName":"333333","FilmNum":"3333333"FilmPlay":"1"},{"FilmName":"444444","FilmNum":"4444444"FilmPlay":"1"}]
JSONHelp类：
using System;
using System.Collections.Generic;
using System.Web.Script.Serialization;
using System.Text;namespace MovieLib
{
    public static class DbHelperJson
    {
        static DbHelperJson()
        { }
        /// <summary>
        /// 将对象序列化为JSON数据
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public static string ToJsonString(this object obj)
        {
            JavaScriptSerializer Serializer = new JavaScriptSerializer();
            return Serializer.Serialize(obj);
        }        /// <summary>
        /// 将JSON对象反序列化为字符串
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="str"></param>
        /// <returns></returns>
        public static T JsonToString<T>(this string str)
        {
            JavaScriptSerializer Serializer = new JavaScriptSerializer();
            return Serializer.Deserialize<T>(str);
        }
    }
}JSON中字段的实体类：
using System;namespace MovieMod
{
    /// <summary>
    /// 实体类Mod_FilmItem 。(属性说明自动提取数据库字段的描述信息)
    /// </summary>
    [Serializable]
    public class Mod_FilmItem
    {
        public Mod_FilmItem()
        { }
        #region Model
        private string _filmname;
        /// <summary>
        /// 名称
        /// </summary>
        public string FilmName
        {
            get { return _filmname; }
            set { _filmname = value; }
        }
        private string _filmnum;
        /// <summary>
        /// 集数
        /// </summary>
        public string FilmNum
        {
            get { return _filmnum; }
            set { _filmnum = value; }
        }
        private string _filmplay;
        /// <summary>
        /// 排序
        /// </summary>
        public string FilmPlay
        {
            get { return _filmplay; }
            set { _filmplay = value; }
        }
        #endregion Model
    }
}使用方法：List<Mod_FilmItem> MFitem = _StrJson.JsonToString<List<Mod_FilmItem>>();
                if (MFitem.Count != 0)
                {
                    StringBuilder _StrBuild = new StringBuilder();
                    _StrBuild.Append("<table border=\"0\" cellspacing=\"0\" cellpadding=\"0\" id=\"FilmScan_Table\">");
                    for (int i = 0; i < MFitem.Count; i++)
                    {
                        _StrBuild.Append("<tr>");
                        _StrBuild.Append("<td style=\"height: 35px; width: 220px;\"><input name=\"FilmUrl_Name\" type=\"text\" class=\"TBoxFilmUrl\" maxlength=\"200\" value=\"" + MFitem[i].FilmName + "\" style=\"width: 200px;\" /></td>");
                        _StrBuild.Append("<td style=\"width: 150px;\"><input name=\"FilmUrl_Num\" type=\"text\" class=\"TBoxFilmUrl\" maxlength=\"200\" value=\"" + MFitem[i].FilmNum + "\" /></td>");
                        _StrBuild.Append("<td style=\"width: 150px;\">");
                        _StrBuild.Append("<select name=\"SelectFilmPlay\">");
                        if (BPlay._GetModelList("").Count == 0)
                        {
                            _StrBuild.Append("<option value=\"0\">暂无任何播放器</option>");
                        }
                        else
                        {
                            foreach (var PlayItem in ListMPlay)
                            {
                                if (Convert.ToInt32(MFitem[i].FilmPlay) == PlayItem.ID)
                                {
                                    _StrBuild.Append("<option value=\"" + PlayItem.ID + "\" selected=\"selected\">" + PlayItem.PlayName + "</option>");
                                }
                                else
                                {
                                    _StrBuild.Append("<option value=\"" + PlayItem.ID + "\">" + PlayItem.PlayName + "</option>");
                                }
                            }
                        }
                        _StrBuild.Append("</select>");
                        _StrBuild.Append("</td>");
                        _StrBuild.Append("<td style=\"width: 70px;\"><input id=\"ButDelItem\" type=\"button\" value=\"\" class=\"ButDel\" onclick=\"DelFilmRow(this);\" /></td>");
                        _StrBuild.Append("</tr>");
                    }
                    _StrBuild.Append("</table>");
                    return _StrBuild.ToString();
                }
                else
                {
                    return null;
                }
这样就可以了。。你自已看看吧。。应该稍改一下就可以用了的。。

Answer 11

也可以直接用JS解析的啊。。我那第一个贴子就是用JQ直接解析JSON的啊。 。

Answer 12

15楼的兄弟，，你的类Mod_FilmItem没有实现嵌套，如果有嵌套怎么办，，，?这里的JSON数据是有嵌套的。。关键就是这个地方！！

Answer 13

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Json;namespace ConsoleApplication1
{    //实体类父类
    public class class2
    {
        private string _c;
        public string c { get { return _c; } set { _c = value; } }
        private List<class3> _d;
        public List<class3> d { get { return _d; } set { _d = value; } }
    }
    //实体类子类
    public class class3
    {
        private string _a;
        public string a { get { return _a; } set { _a = value; } }
        private string _b;
        public string b { get { return _b; } set { _b = value; } }
    }
    class Program
    {
        static void Main(string[] args)
        {
            //json string
            string json = "[{\"c\":\"理\",\"d\":[{\"a\":\"数学\",\"b\":\"上午\"},{\"a\":\"地理\",\"b\":\"下午\"}]},{\"c\":\"文\",\"d\":[{\"a\":\"历史\",\"b\":\"下午\"},{\"a\":\"政治\",\"b\":\"上午\"}]}]";
            //序列化
            List<class2> entities = Deserialize<class2>(json);
        }
        /// <summary>
        /// 序列化成Json
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="entities"></param>
        /// <returns></returns>
        public static string Serializer<T>(T entities)
        {
            DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(T));
            using (MemoryStream ms = new MemoryStream())
            {
                ser.WriteObject(ms, entities);
                string json = Encoding.UTF8.GetString(ms.ToArray());
                ms.Close();
                return json;
            }
        }
        /// <summary>
        /// 序列化成Json
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="entities"></param>
        /// <returns></returns>
        public static string Serializer<T>(List<T> entities)
        {
            DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(List<T>));
            using (MemoryStream ms = new MemoryStream())
            {
                ser.WriteObject(ms, entities);
                string json = Encoding.UTF8.GetString(ms.ToArray());
                ms.Close();
                return json;
            }
        }
        /// <summary>
        /// 反序列化成实体对象
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="str"></param>
        /// <returns></returns>
        public static T DeserializeToEntity<T>(string str)
        {
            DataContractJsonSerializer json = new DataContractJsonSerializer(typeof(T));
            using (MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes(str)))
            {
                T entity = (T)json.ReadObject(stream);
                stream.Close();
                return entity;
            }
        }
        /// <summary>
        /// 反序列化成实体集合对象
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="str"></param>
        /// <returns></returns>
        public static List<T> Deserialize<T>(string str)
        {
            DataContractJsonSerializer json = new DataContractJsonSerializer(typeof(List<T>));
            using (MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes(str)))
            {
                List<T> entities = (List<T>)json.ReadObject(stream);
                stream.Close();
                return entities;
            }
        }
    }
}

Answer 14

问题不在JSON结构问题在于你如何去架构你的实体结构

Answer 15

//综合上次你的提问，完整代码都发给你了
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Json;namespace ConsoleApplication1
{    //单个实体类
    public class class1
    {
        private string id;
        public string ID { get { return id; } set { id = value; } }
        private string order;
        public string Order { get { return order; } set { order = value; } }
    }
    //实体父类
    public class class2
    {
        private string _c;
        public string c { get { return _c; } set { _c = value; } }
        //子类关系属性
        private List<class3> _d;
        public List<class3> d { get { return _d; } set { _d = value; } }
    }
    //实体子类
    public class class3
    {
        private string _a;
        public string a { get { return _a; } set { _a = value; } }
        private string _b;
        public string b { get { return _b; } set { _b = value; } }
    }
    class Program
    {
        static void Main(string[] args)
        {
            //json字符串
            string bar = "[{\"ID\":\"3\",\"Order\":\"9\"},{\"ID\":\"1\",\"Order\":\"6\"},{\"ID\":\"2\",\"Order\":\"8\"}]";
            //序列化json成实体类集合
            List<class1> newEntities = Deserialize<class1>(bar);
            //linq排序
            var s = from l in newEntities orderby l.ID select l;
            //实体类集合反序列化成json
            string j = Serializer<class1>(newEntities);
            //单个实体类凡序列化成json
            string entityjsn = Serializer<class1>(newEntities[0]);
            //json反序列化成单个实体类
            class1 entity = DeserializeToEntity<class1>(entityjsn);
            
            //多结构JSON
            string json = "[{\"c\":\"理\",\"d\":[{\"a\":\"数学\",\"b\":\"上午\"},{\"a\":\"地理\",\"b\":\"下午\"}]},{\"c\":\"文\",\"d\":[{\"a\":\"历史\",\"b\":\"下午\"},{\"a\":\"政治\",\"b\":\"上午\"}]}]";
            // ==> 实例化实体
            List<class2> sj = Deserialize<class2>(json);
        }
        /// <summary>
        /// 序列化成Json
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="entities"></param>
        /// <returns></returns>
        public static string Serializer<T>(T entities)
        {
            DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(T));
            using (MemoryStream ms = new MemoryStream())
            {
                ser.WriteObject(ms, entities);
                string json = Encoding.UTF8.GetString(ms.ToArray());
                ms.Close();
                return json;
            }
        }
        /// <summary>
        /// 序列化成Json
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="entities"></param>
        /// <returns></returns>
        public static string Serializer<T>(List<T> entities)
        {
            DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(List<T>));
            using (MemoryStream ms = new MemoryStream())
            {
                ser.WriteObject(ms, entities);
                string json = Encoding.UTF8.GetString(ms.ToArray());
                ms.Close();
                return json;
            }
        }
        /// <summary>
        /// 反序列化成实体对象
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="str"></param>
        /// <returns></returns>
        public static T DeserializeToEntity<T>(string str)
        {
            DataContractJsonSerializer json = new DataContractJsonSerializer(typeof(T));
            using (MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes(str)))
            {
                T entity = (T)json.ReadObject(stream);
                stream.Close();
                return entity;
            }
        }
        /// <summary>
        /// 反序列化成实体集合对象
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="str"></param>
        /// <returns></returns>
        public static List<T> Deserialize<T>(string str)
        {
            DataContractJsonSerializer json = new DataContractJsonSerializer(typeof(List<T>));
            using (MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes(str)))
            {
                List<T> entities = (List<T>)json.ReadObject(stream);
                stream.Close();
                return entities;
            }
        }
    }
}

Answer 16

那你认为实体类是如何嵌套的？树型？实体类的嵌套  是父类和子类构造而成，当然就是有类型决定他们的关系。想构造一个完全和JSON一样格式的实体类那是行不通的。   //实体父类
    public class class2
    {
        private string _c;
        public string c { get { return _c; } set { _c = value; } }
        //子类关系属性
        private List<class3> _d;
        public List<class3> d { get { return _d; } set { _d = value; } }
    }
    //实体子类
    public class class3
    {
        private string _a;
        public string a { get { return _a; } set { _a = value; } }
        private string _b;
        public string b { get { return _b; } set { _b = value; } }
    }class1内的d属性 就是子集合体，也就是你说的嵌套

Answer 17

using Newtonsoft.Json; //需要单独下载,添加引用后面有下载地址.
using Newtonsoft.Json.Linq;public class Course
    {
        private string _c;
        private SelectedCourse _d;
        public string C
        {
            set { this._c = value; }
            get { return this._c; }
        }
        public SelectedCourse D
        {
            set { this._d = value; }
            get { return this._d; }
        }
    }    public class SelectedCourse
    {
        private string _a;
        private string _b;
        public string A
        {
            set { this._a = value; }
            get { return this._a; }
        }
        public string B
        {
            set { this._b = value; }
            get { return this._b; }
        }
    }    public class Courses : List<Course> { }
使用的时候这样用
            string jsonValue = "你的JSON字符串";
            Courses courses = JsonConvert.DeserializeObject<Courses>(jsonValue);
            foreach (Course course in Courses)
            {
                course.C;
                course.D;
                course.D.A;
                course.D.B;
            }Newtonjson.dll的下载地址. 使用之前需要添加Add Reference.并使用http://download.csdn.net/source/1971006JSON的操作方法的教程:
http://blog.ioops.net/archives/176.html

Answer 18

晕。。有嵌套大不了多次循环呗JSON数据结构无所谓。。取值是根据你的结构取就行了。。