c#多层嵌套Json

最新推荐文章于 2024-02-29 16:40:44 发布
最新推荐文章于 2024-02-29 16:40:44 发布
阅读量1.5k 收藏 2
点赞数
分类专栏： 随记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xingzhiqing/article/details/102367682
版权

1、类+list：

 

 public class OrderInfo
    {
        /// <summary>
        /// 桌台状态表
        /// </summary>
        [DataMember]
        public string bi_deskroom_status { get; set; }
        /// <summary>
        /// 销售主表
        /// </summary>
        [DataMember]
        public string pos_master { get; set; }
        /// <summary>
 

public class pos_master
    {
        [DataMember]
        public string errcode { get; set; }

        [DataMember]
        public string errmsg { get; set; }

        [DataMember]
        public List<pos_detail> p_detail;


        /// <summary>
        /// 销售明细表
        /// </summary>
        [DataMember]
        public string detail { get; set; }

        /// <summary>
        /// 企业id
        /// </summary>
        [DataMember]
        public string softid { get; set; }

        /// <summary>
        /// 单号
        /// </summary>
        [DataMember]
        public string sheet_no { get; set; }

  orderInfo.pos_master = grammar_ResultB;

 var p_master = Newtonsoft.Json.JsonConvert.DeserializeObject<po_master>(orderInfo.pos_master);
  List<pos_master> master = p_master.TableInfo;

 var p_detail = Newtonsoft.Json.JsonConvert.DeserializeObject<po_detail>(orderInfo.pos_detail);
 List<pos_detail> detail = p_detail.TableInfo;
               
 var p_detailcs = Newtonsoft.Json.JsonConvert.DeserializeObject<po_detailcs>(orderInfo.pos_detailcs);
  List<pos_detailcs> detailcs = p_detailcs.TableInfo;
              
  var p_detailtaste = Newtonsoft.Json.JsonConvert.DeserializeObject<po_detailtaste>(orderInfo.pos_detailtaste);
 List<pos_detailtaste> detailtaste = p_detailtaste.TableInfo;
             

                try
                {
                    if (grammar_ResultB.IndexOf("查询无数据") > 0)
                    {
                        return dberror.errorStr("40050");
                    }
                    else
                    {
                        foreach (pos_master po in master)
                        {

                            //errcode  errmsg
                            if (po.errcode != "40015")
                            {
                                po.p_detail = null;
                            }
                            else
                            {
                            }

                            po.p_detail = null;
                            if (grammar_ResultC.IndexOf("查询无数据") > 0)
                            {
                                return dberror.errorStr("40051");
                            }
                            else
                            {
                                foreach (pos_detail pi in detail)
                                {
                                   
                                    if (po.sheet_no == pi.sheet_no)
                                    {
                                        po.p_detail = detail;
                                    }
                                    else
                                    {
                                       
                                    }

                                    if (pi.errcode != "")
                                    {
                                        pi.p_detailcs = null;
                                        pi.p_detailtaste = null;
                                    }
                                    else
                                    {
                                    }

                                    pi.p_detailcs = null;
                                    if (grammar_ResultD.IndexOf("查询无数据") > 0)
                                    {
                                        pi.p_detailcs = null;
                                       
                                    }
                                    else
                                    {
                                        List<pos_detailcs> detailcs0 = new List<pos_detailcs>();
                                        foreach (pos_detailcs pd in detailcs)
                                        {

                                           // pi.item_money = 0;
                                            if ( pi.sheet_sort == pd.sheet_sort)
                                            {
                                                 detailcs0.Add(pd);
                                                pi.item_money =  Convert.ToDouble(pi.real_amt) + Convert.ToDouble(pi.add_amt);
                                              
                                            }
                                            else
                                            {             
                                            }

                                            if (pd.errcode != "")
                                            {
                                                pd.p_detailtaste = null;
                                            }
                                            else
                                            {
                                            }

                                            pd.p_detailtaste = null;
                                            if (grammar_ResultE.IndexOf("查询无数据") > 0)
                                            {
                                                //return dberror.errorStr("40053");
                                                pd.p_detailtaste = null;
                                            }
                                            else
                                            {
                                                List<pos_detailtaste> detailtaste0 = new List<pos_detailtaste>();
                                                foreach (pos_detailtaste pe in detailtaste)
                                                {
                                                    
                                                    
                                                    if ( pd.item_id == pe.item_id&& pd.child_sort == pe.sheet_sort)
                                                    {
                                                        detailtaste0.Add(pe);
                                                        pd.item_money = pd.item_money + Convert.ToDouble(pe.add_range);
                                                    }
                                                    else
                                                    {
                                                       
                                                    }

                                                }
                                                pd.p_detailtaste = detailtaste0;
                                               
                                            }
                                        }
                                        pi.p_detailcs = detailcs0;
                                        pi.item_money = pi.item_money;

                                    }

                                    pi.p_detailtaste = null;
                                    if (grammar_ResultE.IndexOf("查询无数据") > 0)
                                    {
                                        // return dberror.errorStr("40053");
                                        pi.p_detailtaste = null;
                                    }
                                    else
                                    {
                                       // int m = 0;
                                      List<pos_detailtaste> detailtaste0 = new List<pos_detailtaste>();
                                        foreach (pos_detailtaste pf in detailtaste)
                                        {
                                           // List<pos_detailtaste> detailtaste0 = new List<pos_detailtaste>();
                                           

                                            if ( pi.sheet_sort == pf.sheet_sort)
                                            {
                                                detailtaste0.Add(pf);
                                                //pi.item_money + Convert.ToDouble(pf.add_range);
                                            }
                                            else
                                            {
                                               
                                            }
                                        
                                        }
                                        pi.p_detailtaste = detailtaste0;
                                        pi.item_money = Convert.ToDouble(pi.add_amt) + Convert.ToDouble(pi.real_amt);
                                        pi.item_money = pi.item_money;
                                    }
                                }
                            }
                        }
                    }

                      
                }
                catch (Exception ex)
                {
                    
                    return dberror.errorStr("40015");
                    throw ex;
                }

               return Newtonsoft.Json.JsonConvert.SerializeObject(master); //return Jayrock.Json.Conversion.JsonConvert.ExportToString(master);

                }
                catch (Exception ex)
                {

                    #region 异常
                    if (i < 3)
                    {
                        i++;
                        goto InitInfoA;
                    }
                    if (upoint != null) {
                        messenger.gush(upoint);
                    }
                    return dberror.errorStr("40017");
                    throw ex;
                    #endregion

                }

        }

 

2、类+类：

public class UserInfo

{

public string name;

public int age;

public address addr;

}

public class address

{

public string city;

public string province;
}

然后参照1给类for循环赋值

3、转换成table，表操作，然后转list

 public static class jsonObject
        {
            #region DataTable 转换为Json 字符串
            /// <summary>
            /// DataTable 对象 转换为Json 字符串
            /// </summary>
            /// <param name="dt"></param>
            /// <returns></returns>
            public static string ToJson(this DataTable dt)
            {
                JavaScriptSerializer javaScriptSerializer = new JavaScriptSerializer();
                javaScriptSerializer.MaxJsonLength = Int32.MaxValue; //取得最大数值
                ArrayList arrayList = new ArrayList();
                foreach (DataRow dataRow in dt.Rows)
                {
                    Dictionary<string, object> dictionary = new Dictionary<string, object>();  //实例化一个参数集合
                    foreach (DataColumn dataColumn in dt.Columns)
                    {
                        dictionary.Add(dataColumn.ColumnName, dataRow[dataColumn.ColumnName].ToString());
                    }
                    arrayList.Add(dictionary); //ArrayList集合中添加键值
                }
                return javaScriptSerializer.Serialize(arrayList);  //返回一个json字符串
            }
            #endregion

            #region Json 字符串 转换为 DataTable数据集合
            /// <summary>
            /// Json 字符串 转换为 DataTable数据集合
            /// </summary>
            /// <param name="json"></param>
            /// <returns></returns>
            public static DataTable ToDataTable(this string json)
            {
                DataTable dataTable = new DataTable();  //实例化
                DataTable result;
                try
                {
                    JavaScriptSerializer javaScriptSerializer = new JavaScriptSerializer();
                    javaScriptSerializer.MaxJsonLength = Int32.MaxValue; //取得最大数值
                    ArrayList arrayList = javaScriptSerializer.Deserialize<ArrayList>(json);
                    if (arrayList.Count > 0)
                    {
                        foreach (Dictionary<string, object> dictionary in arrayList)
                        {
                            if (dictionary.Keys.Count<string>() == 0)
                            {
                                result = dataTable;
                                return result;
                            }
                            if (dataTable.Columns.Count == 0)
                            {
                                foreach (string current in dictionary.Keys)
                                {
                                dataTable.Columns.Add(current, Type.GetType("System.String"));// dictionary[current].GetType());
                                }
                            }
                            DataRow dataRow = dataTable.NewRow();
                            foreach (string current in dictionary.Keys)
                            {
                                dataRow[current] = dictionary[current];
                            }

                            dataTable.Rows.Add(dataRow); //循环添加行到DataTable中
                        }
                    }
                }
            catch (Exception ex)
            {
               //* return dberror.errorStr("40015");
                throw ex;
            }
            result = dataTable;
                return result;
            }
        #endregion

        public static DataTable ListToDataTableA( List<pos_master> collection)
        {
            var props = typeof(pos_master).GetProperties();
            var master_dt = new DataTable();
            master_dt.Columns.AddRange(props.Select(p => new DataColumn(p.Name, p.PropertyType)).ToArray());
            if (collection.Count() > 0)
            {
                for (int m = 0; m < collection.Count(); m++)
                {
                    ArrayList tempList = new ArrayList();
                    foreach (PropertyInfo pi in props)
                    {
                        object obj = pi.GetValue(collection.ElementAt(m), null);
                        tempList.Add(obj);
                    }
                    object[] array = tempList.ToArray();
                    master_dt.LoadDataRow(array, true);
                    //master_dt =Convert(array);
                }
            }
            return master_dt;
        }

        /*public static DataTable Convert(string[,] Arrays)
        {
            DataTable dt = new DataTable();

            int a = Arrays.GetLength(0);
            for (int i = 0; i < Arrays.GetLength(1); i++)
            {
                dt.Columns.Add("col" + i.ToString(), typeof(string));
            }

            for (int i1 = 0; i1 < Arrays.GetLength(0); i1++)
            {
                DataRow dr = dt.NewRow();
                for (int i = 0; i < Arrays.GetLength(1); i++)
                {
                    dr[i] = Arrays[i1, i].ToString();
                }
                dt.Rows.Add(dr);
            }

            return dt;

        }*/


        public static DataTable ListToDataTableB(List<pos_detail> collection)
        {
            var props = typeof(pos_master).GetProperties();
            var master_dt = new DataTable();
            master_dt.Columns.AddRange(props.Select(p => new DataColumn(p.Name, p.PropertyType)).ToArray());
            if (collection.Count() > 0)
            {
                for (int m = 0; m < collection.Count(); m++)
                {
                    ArrayList tempList = new ArrayList();
                    foreach (PropertyInfo pi in props)
                    {
                        object obj = pi.GetValue(collection.ElementAt(m), null);
                        tempList.Add(obj);
                    }
                    object[] array = tempList.ToArray();
                    master_dt.LoadDataRow(array, true);
                }
            }
            return master_dt;
        }

    

    public static DataTable ListToDataTableC(List<pos_detailcs> collection)
    {
        var props = typeof(pos_master).GetProperties();
        var master_dt = new DataTable();
        master_dt.Columns.AddRange(props.Select(p => new DataColumn(p.Name, p.PropertyType)).ToArray());
        if (collection.Count() > 0)
        {
            for (int m = 0; m < collection.Count(); m++)
            {
                ArrayList tempList = new ArrayList();
                foreach (PropertyInfo pi in props)
                {
                    object obj = pi.GetValue(collection.ElementAt(m), null);
                    tempList.Add(obj);
                }
                object[] array = tempList.ToArray();
                master_dt.LoadDataRow(array, true);
            }
        }
        return master_dt;
    }


    public static DataTable ListToDataTableD(List<pos_detailtaste> collection)
    {
        var props = typeof(pos_master).GetProperties();
        var master_dt = new DataTable();
        master_dt.Columns.AddRange(props.Select(p => new DataColumn(p.Name, p.PropertyType)).ToArray());
        if (collection.Count() > 0)
        {
            for (int m = 0; m < collection.Count(); m++)
            {
                ArrayList tempList = new ArrayList();
                foreach (PropertyInfo pi in props)
                {
                    object obj = pi.GetValue(collection.ElementAt(m), null);
                    tempList.Add(obj);
                }
                object[] array = tempList.ToArray();
                master_dt.LoadDataRow(array, true);
            }
        }
        return master_dt;
    }
}
}

星之擎
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C#对多级json解析
03-26
C#对多级json解析,非常实用，此代码写在load事件里面，然后可以了解解析json的原理。尤其是多级解析。
c# 读取json 的嵌套或多层嵌套数据的简单姿势
nini3816的博客
04-09 5464
看了一些资料，感觉都很垃圾，或者废话多，将自己搜寻的比较简单的方法写下。需要用NuGet安装Newtonsoft.Json库 json文件为configWRC.json如下内容 { "JiDianQi_IP": "192.168.1.253", "QuanJingCameraIP": "192.168.1.123", "Name":"jueshi", "Damage":21, ...
C#解析JSON
最新发布
zunguitiancheng的专栏
02-29 1315
全称“JavaScript Object Notation（JavaScript对象表示法）”，JSON 是存储和交换文本信息的语法。"id": 2,"name": "星河爆破",},"id": 3,"name": "九星连珠",},"id": 4,"name": "一语成谶",学习JSON基础教程在线JSON解析在线JSON解析及格式化验证网站。
C# JSON 泛型解析
09-15
多层嵌套的JSON字符串也可以解析，泛型T的属性要和JSON字符串反序列化的对象属性一致。
C# 获取json字段中指定值
02-11
C# 获取json字段中指定的值，省去写对象的烦恼，从而提升了代码的可读性,加速了json格式数据的解析和管理，直接调用有用的数据
基于Newtonsoft.Json实现Json数据解析和封装
06-02
Newtonsoft.Json已经足够强大，易用性也没得说。但是在使用过程中存在着一个问题，如果数据不存在需要判空的逻辑，这种判空逻辑会扩散在代码的各个角落，很容易犯错。 本文就是为了将这个变化点收缩到一处，便于控制。设计中也分别对JObject类和JArray类进行了封装。JObject的封装类是JsonObject，JArray的封装类是JsonArray类。JsonObject类和JsonArray类可以相互嵌套，支持原生类的JsonPath检索能力，满足Json数据解析和Json数据封装常见需求。
JSON的创建以及内部键值对的拼接
BigHippos的博客
05-03 6831
创建json var params=new Object(); 添加键值 params.id=1; params.name="校长2008" 显示效果 {“id”:"1","name":"校长2008"} 事例-如何拼接json内部的键值对 创建对应的key值数组：keys["userid","username","tel"]创建json； var params=ne
JSON 格式的数据
spoony_peng的专栏
08-18 376
可以创建一个新的 JavaScript 变量，然后将 JSON 格式的数据字符串直接赋值给它： var people = { "programmers": [ { "firstName": "Brett", "lastName":"McLaughlin", "email": "[email protected]" }, { "firstName": "Jason", "lastName":"Hunter", "email": "[email protected]" },
多级嵌套json反序列化为实体对象 c#
qq_33782655的博客
03-11 4973
使用c#代码对json文件中的值进行修改，修改后再序列化为json文件 将多级嵌套的json文件，转化为类对象，反序列化 目录 1.转化为类对象 2. json文件反序列化 3. 获取并修改属性值 4. 序列化 1.转化为类对象 json文件如下： json文件放置在我本地文件夹：D:\2021\test.json (1) 在vs中新建一个类 点击自己的project->右键-》Add-》New Item-》ProjectName.cs (2) 打开要转化的json文件..
C# 生成多层嵌套JSON到数组中(树结构JSON)
热门推荐
kongwei521的专栏
09-13 1万+
DataTable dt = DbHelperSQL.Query(sql).Tables[0]; var changeinfo = string.Empty; JavaScriptSerializer js = new JavaScriptSerializer(); List l
遍历多级树状json获得父子节点值
05-30
此方法可快速循环遍历多级嵌套或树状json结构，根据传入的参数获得对应的父子节点的属性值。
详解ASP.NET提取多层嵌套json数据的方法
10-20
本篇文章主要介绍了ASP.NET提取多层嵌套json数据的方法，利用第三方类库Newtonsoft.Json提取多层嵌套json数据的方法，有兴趣的可以了解一下。
C# json解析与生成json字符串
琅嬛福地
06-12 4600
在C#中使用Newtonsoft.Json解析JSON，首先需要安装Newtonsoft.Json NuGet包。可以通过以下步骤进行安装：(1) 打开Visual Studio项目。(2) 在“解决方案资源管理器”中，右键单击项目，然后选择“管理NuGet程序包”。在NuGet包管理器中，搜索“Newtonsoft.Json”。找到Newtonsoft.Json包，点击安装按钮。如下图安装完成后，就可以在C#代码中使用Newtonsoft.Json来解析JSON了。
C# 对json对象嵌套数组
weixin_30267691的博客
09-30 595
看图： 这里可以看到是二层嵌套！！使用C#如何实现？？ 思路：使用list集合实现 → 建立类 → list集合 → 微软的 Newtonsoft.Json （一款.NET中开源的Json序列化和反序列化） sonXMText类 using System; using System.Collections.Generic; using System.Linq; usin...
C# ASP.NET递归多层内循环生成嵌套json结构树-1
小熊猫
02-06 1309
可用于内循环，树形结构数据， layui.tree等结构。1. 建立用来保存树结构数据的目标对象。2.查询表获得数据源。
c# 实体集合转多层json数据
qq_33380252的博客
03-22 2040
问答原网址:https://ask.csdn.net/questions/752801 mysql数据库图片： 用ef生成实体模型,增加childList字段，用来存子数据 public partial class ces { public int id { get; set; } public Nullable<int> pid {...
c# 多层json 解析方法
nnnnnnnnnnnnnnni的博客
08-18 1608
c# 多层json 解析方法
unity json多层嵌套解析
05-25
在Unity中，可以使用JsonUtility类来解析Json格式的数据。对于多层嵌套的Json数据，我们可以使用JsonUtility.FromJson方法将其转换为对应的C#对象，然后再通过对象的属性或方法来访问其中的数据。 下面是一个示例Json数据： ``` { "name": "John", "age": 30, "address": { "city": "New York", "state": "NY", "zipcode": "10001" }, "phoneNumbers": [ { "type": "home", "number": "555-1234" }, { "type": "work", "number": "555-5678" } ] } ``` 我们可以定义一个对应的C#类来表示这个Json数据： ``` [Serializable] public class Person { public string name; public int age; public Address address; public List<PhoneNumber> phoneNumbers; } [Serializable] public class Address { public string city; public string state; public string zipcode; } [Serializable] public class PhoneNumber { public string type; public string number; } ``` 然后使用JsonUtility.FromJson方法将Json数据转换为Person对象： ``` string jsonData = "{...}"; // 假设这里是示例Json数据 Person person = JsonUtility.FromJson<Person>(jsonData); ``` 现在我们就可以通过person对象的属性或方法来访问其中的数据了，例如： ``` Debug.Log(person.name); // 输出 "John" Debug.Log(person.address.city); // 输出 "New York" Debug.Log(person.phoneNumbers[0].number); // 输出 "555-1234" ``` 需要注意的是，在使用JsonUtility类时，对象的属性或字段必须是public修饰的，并且类必须使用[Serializable]标记进行标记。此外，Json数据中的键名必须与C#类中的属性或字段名称相对应。如果Json数据中的键名与属性或字段名称不匹配，可以使用[JsonProperty]标记来指定对应关系。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

星之擎

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值