Jobject 使用

.NET跨平台

已于 2022-07-30 12:42:36 修改

阅读量2.8k

点赞数 1

分类专栏： Newtonsoft.Json框架文章标签： c# linq json

于 2022-07-29 01:04:51 首次发布

原文链接：https://blog.csdn.net/WuLex

版权

Newtonsoft.Json框架专栏收录该内容

21 篇文章 3 订阅

订阅专栏

var obj2 = JObject.Parse(result.Html);
JArray _Jarr = _obj["data"]["siteList"].Value<JArray>();
if (_Jarr == null)
return;
//bool isym= _Jarr.Any(p => p["url"].Value<string>().Contains("gangzan.com"));

   //bool hasErr = _obj.Properties().Any(p => p.Name == "err");//或是这样
                //var names = from domains in _obj["data"]["siteList"].Children()
                //            select (string)domains["url"];
                foreach (var name in names)
                {

                }
                //return names;
                //

                
                //IEnumerable<JProperty> properties = _obj.Properties();
                //foreach (JProperty item in properties)
                //{

                //    Console.WriteLine(item.Name + ":" + item.Value);
                //}
                

                //MessageBox.Show(_obj["data"]["siteList"][0].Value<string>());
 

//保留数据
//JEnumerable<JToken> ss = _Jarr[0]["tkSpecialCampaignIdRateMap"].Children();
//foreach (var items in ss)
// DPlan.Add(((JProperty)(items)).Name, float.Parse(((JProperty)(items)).Value.ToString()));
var dicSort = from objDic in DPlan orderby objDic.Value descending select objDic;

`JToken JObject JArray` 使用示例

using System;
using System.Linq;
using System.Collections.Generic;
using Newtonsoft.Json.Linq;
using System.Diagnostics;

namespace ahaley.AtTask
{
    public class PayrollMapper : IPayrollMapper
    {
        const int BaseWeekHour = 40;

        public Payroll[] MapAggregateJsonToPayroll(JToken aggregatePayrollJson, JToken expensesJson = null)
        {
            var payrollItems = new List<Payroll>();
            foreach (JToken j in aggregatePayrollJson.Children()) {
                payrollItems.Add(MapJsonToPayroll(j, expensesJson));
            }
            return payrollItems.ToArray();
        }

        static double CalculateRegular(Payroll p)
        {
            return Math.Min(BaseWeekHour, p.TotalHours - p.PaidTimeOff - p.AbsentHours - p.OvertimeHours - p.SuspensionHours);
        }

        static double CalculateOvertime(Payroll p)
        {
            return Math.Max(0, p.TotalHours - BaseWeekHour - p.AbsentHours - p.SuspensionHours);
        }

        public Payroll MapJsonToPayroll(JToken payrollJson, JToken expenses = null)
        {
            Payroll payrollItem = GetPayrollItem(payrollJson);

            payrollItem.RegularHours = CalculateRegular(payrollItem);
            payrollItem.OvertimeHours = CalculateOvertime(payrollItem);

            ApplyExpenses(expenses, payrollItem);

            DateTime weekEndingUtc = payrollItem.WeekEnding;

            payrollItem.WeekEnding = weekEndingUtc.Subtract(TimeZone.CurrentTimeZone.GetUtcOffset(weekEndingUtc));

            return payrollItem;
        }

        static Payroll GetPayrollItem(JToken payrollJson)
        {
            JObject user = payrollJson.Value<JObject>("user");
            string employeeID = payrollJson.Value<string>("userID");
            DateTime endDate = payrollJson.Value<string>("endDate").FromAtTaskDate();

            var payroll = new Payroll() {
                Firstname = user.Value<string>("firstName"),
                Lastname = user.Value<string>("lastName"),
                EmployeeID = employeeID,
                NWBHours = payrollJson.CountHourType(HourType.NightWorkBonus),
                PaidTimeOff = payrollJson.CountHourType(HourType.PaidTimeOff),
                TotalHours = payrollJson.Value<double>("totalHours"),
                WeekEnding = endDate,
                RegularHours = payrollJson.Value<double>("regularHours"),
                OvertimeHours = payrollJson.Value<double>("overtimeHours"),
                AbsentHours = payrollJson.CountHourType(HourType.Absent),
                HolidayHours = payrollJson.CountHourType(HourType.Holiday),
                SuspensionHours = payrollJson.CountHourType(HourType.Suspension)
            };
            return payroll;
        }

        static void ApplyExpenses(JToken expensesJson, Payroll payroll)
        {
            if (null == expensesJson)
                return;

            List<JToken> relevantExpenses = ExtractRelevantExpenses(expensesJson, payroll);

            Func<string, double> expenseForType = (expenseTypeID) => (from e in relevantExpenses
                                                                      where e.Value<string>("expenseTypeID") == expenseTypeID
                                                                      select e.Value<double>("actualUnitAmount")).Sum();

            payroll.InChargeDays = expenseForType(ExpenseType.InChargeExpenseType);
            payroll.TotalMileage = expenseForType(ExpenseType.MileageExpenseType);
            payroll.TotalPerDiem = expenseForType(ExpenseType.PerDiem);
        }

        static List<JToken> ExtractRelevantExpenses(JToken expensesJson, Payroll payroll)
        {
            var weekEnding = (payroll.WeekEnding + TimeSpan.FromDays(7 - (int)payroll.WeekEnding.DayOfWeek)).Date;
            var weekStarting = weekEnding.AddDays(-6);

            JEnumerable<JToken> children = expensesJson.Children();

            var elts = children.Where(x => {
                JToken ownerToken = x["DE:Expense Owner"];
                //JToken ownerToken = x.SelectToken("DE:Expense Owner");

                if (ownerToken == null)
                    return false;

                if (ownerToken is JArray) {
                    IJEnumerable<JToken> owners = (ownerToken as JArray).Values();
                    if (!owners.Any(s => ((string)s).Contains(payroll.EmployeeID)))
                        return false;
                }
                else {
                    string owner = (string)ownerToken;
                    if (owner == null || !owner.Contains(payroll.EmployeeID))
                        return false;
                    else {
                        Debug.WriteLine("at least once");
                    }
                }

                var effectiveDate = DateTime.Parse(x.Value<string>("effectiveDate"));

                var valid = weekStarting <= effectiveDate && effectiveDate <= weekEnding;

                if (valid) {
                    Debug.WriteLine("we're valid");
                }

                return valid;
            });

            return elts.ToList();
        }
    }
}

动态Json字符串的解析

对于传统的Json字符串，比如有规定属性的对象，通常都会采用反序列化的方式就可以了，例如下面的方式：

 DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(T));
 MemoryStream ms = newMemoryStream(Encoding.UTF8.GetBytes(jsonString));
 T obj = (T)ser.ReadObject(ms);

但是有时候会出现动态的json字符串，例如：

{
  "workOrderId": "WO170330000375",
  "workOrderData": {
    "workOrderId": "WO170330000376",
    "statusDesc": "执行中",
    "modifyUserId": "system",
    "modifyUserName": "system"
  },
  "formData": {
    "id": "WO170330000377",
    "data": {
      "dbTypes_text": [
        "SqlServer",
        "MySql"
      ],
      
    }
  },
  "approvalLogs": [
    {
      "workOrderId": "WO170330000379",
      "remark": "同意",
      "createTime": {
        "date": 30,
        "hours": 17,
        "seconds": 32
      }
    },
    {
      "workOrderId": "WO170330000380",
      "remark": "同意",
      "createTime": {
        "date": 30,
        "hours": 17,
        "seconds": 46
      }
    }
  ]
}

解析上述字符串

需要引用第三方类库 <Newtonsoft.Json>

取workOrderId值

var jsonobject = JsonConvert.DeserializeObject<JObject>(strJson);
Console.WriteLine(jsonobject["workOrderId"]);

判断节点中是否存在某个元素

JObject jo = JObject.Parse(strJson);
if (jo.Properties().Any(p => p.Name == "workOrderId"))
    Console.WriteLine("true");

采用JProperty来获取

IEnumerable<JProperty> properties = jo.Properties();
foreach (JProperty item in properties)
{
    if (item.Name.Equals("workOrderId"))
    {
        Console.WriteLine(item.Name + ":" + item.Value);
    }
}

取modifyUserId值

var node = jo["workOrderData"]["modifyUserId"];
Console.WriteLine(node.ToString());

//或者
var childss = jo["workOrderData"] as JObject;
foreach (var prip in childss.Properties())
{
    Console.WriteLine("key:" + (prip.Name + "  values:" + (prip.Value)));
}

//或者
var childs = jo["workOrderData"].Children();
IEnumerator enumerator = childs.GetEnumerator();
while (enumerator.MoveNext())
{
    if (enumerator.Current != null)
    {
        var jtoken = (JToken)enumerator.Current;
        if (((JProperty)jtoken).Name.Equals("modifyUserId"))
            Console.WriteLine("key:" + ((JProperty)jtoken).Name + "  values:" + ((JProperty)jtoken).Value);
    }
}

取approvalLogs下的remark值

var arra = (JArray)jo["approvalLogs"];//JArray.Parse(jo["approvalLogs"].ToString());
foreach (var item in arra)
{
    Console.WriteLine(((JObject)item).GetValue("remark"));
}
//或者
var nodes = jo["approvalLogs"].Children();
foreach (var log in nodes)
{
    Console.WriteLine(((JObject)log)["remark"]);
}
//或者
foreach (var log in nodes)
{
    Console.WriteLine(((JObject)log).Property("remark").Value.ToString());
}

取formData下的dbTypes_text的值

var data = (jo["formData"] as JObject).GetValue("data");
var result = ((JObject)data)["dbTypes_text"];
foreach (var item in JArray.Parse(result.ToString()))// (JArray)result
{
Console.WriteLine(item);
}
//或者
var values = result.Children().Values();
foreach (var obj in values)
{
Console.WriteLine(obj.ToString());
}
Console.Read();

递归调用获取节点的方法

private string GetJsonValue(JToken jToken, string key)
    {
        var value = string.Empty;
        if (!(jToken is JObject)) return value;
        var jobj = ((JObject)jToken).Property(key);
        if (jobj == null)
        {
            if (jToken is JObject || (jToken is JProperty && ((JProperty)jToken).Value is JObject))
            {
                if (jToken.Children().Count() > 0)
                {
                    value = GetJsonValue(jToken.Children(), key);
                }
            }
            if (string.IsNullOrWhiteSpace(value) && jToken is JProperty)
            {
                if (((JProperty)jToken).Name == key)
                {
                    value = ((JProperty)jToken).Value.ToString();
                }
            }
        }

        else
        {
            value = jToken[key].ToString();
        }
        return value;
    }
    private string GetJsonValue(JEnumerable<JToken> jToken, string key)
    {
        var value = string.Empty;
        IEnumerator enumerator = jToken.GetEnumerator();
        while (enumerator.MoveNext())
        {
            if (enumerator.Current != null)
            {
                var current = enumerator.Current;

                JToken jc = (JToken)current;
                if (jc is JObject || (jc is JProperty && ((JProperty)jc).Value is JObject))
                {
                    if (jc.Children().Count() > 0)
                    {
                        value = GetJsonValue(jc.Children(), key);
                    }
                }
                if (string.IsNullOrWhiteSpace(value) && jc is JProperty)
                {
                    if (((JProperty)jc).Value is JArray)
                    {
                        var ja = (JArray)((JProperty)jc).Value;
                        foreach (var j in ja)
                        {

                            value = GetJsonValue(j, key);
                            if (!string.IsNullOrWhiteSpace(value))
                                break;
                        }
                    }
                    if (((JProperty)jc).Name == key && string.IsNullOrWhiteSpace(value))
                    {
                        value = ((JProperty)jc).Value.ToString();
                    }
                }

            }
            if (!string.IsNullOrWhiteSpace(value))
                break;
        }
        return value;
    }

C#通用解析JSON保存到数据库

最近我做了一个通用的可配置管理系统。系统中的界面由数据库中的数据显示。本系统与其他系统交互时，需要用到RestFul接口。那么问题来了：如何在不改变代码的情况下编写程序使接口通用？

想一个解决办法：
1、新建接口配置表，字段：接口地址、端口号、接口传输方式等，根据配置表调用接口；

完成
2、将数据库表封装成传出的json；
定义接口时确定JSON消息的格式，使用占位符将数据库表中的数据拼接成JSON（每次调用接口都需要考虑拼接数据的条件）代码不贴；

3、解析传入的json，将数据存入数据库；

将JSON解析成多个DataTable，稍后将代码保存到数据库中；

public static class JsonTextConvert
{
	private static Dictionary<string, DataTable> tbname = new Dictionary<string, DataTable>();


	/* /<summary> */

	/* /parse the json file */

	/* /</summary> */

	/* /<param name='json'></param> */

	public async static Task< Dictionary<string, DataTable> > JsConvert( string jsonText )

	{
		if ( jsonText.Length < 1 )

		{
			return(null);
		}

		tbname.Add( "root", new DataTable( "root" ) );

		JObject dataView = JsonConvert.DeserializeObject<JObject>( jsonText );

		JEnumerable<JToken> jTokens = dataView.Children();

		List<JEnumerable<JToken> > jTokenss = new List<JEnumerable<JToken> >();

		jTokenss.Add( jTokens );

		await Task.Run( () => RecursiveAsync( jTokenss ) );


		return(tbname);
	}


	/* /<summary> */

	/* /Recursively parse json */

	/* /</summary> */

	/* /<param name="jTokens"></param> */

	/* /<returns></returns> */

	private static List< JEnumerable<JToken> > RecursiveAsync( List<JEnumerable<JToken> > jTokens )

	{
		if ( jTokens.Count == 0 )

			return(null);

		List<JEnumerable<JToken> > sss = new List<JEnumerable<JToken> >();

		foreach ( JEnumerable<JToken> jts in jTokens )

		{
			foreach ( JToken jt in jts )

			{
				if ( jt.Type == JTokenType.Object )

					sss.Add( jt.Children() );

				else if ( jt.Type == JTokenType.Property )

				{
					sss.Add( jt.Children() );

					if ( jt.First().Type == JTokenType.Array || jt.First().Type == JTokenType.Object )

						tbname.Add( jt.Path, new DataTable( jt.Path ) );
				}else if ( jt.Type == JTokenType.Array )

				{
					sss.Add( jt.Children() );

					string str = jt.Path.Split( "." ).Last();

					if ( !tbname.Keys.Contains( jt.Path ) )

					{
						if ( str.Contains( "[" ) )

							tbname.Add( jt.Path, new DataTable( str.Substring( 0, str.IndexOf( "[" ) ) ) );

						else

							tbname.Add( jt.Path, new DataTable( str ) );
					}
				}else  {
					foreach ( string s in tbname.Keys )

					{
						string[] ss = jt.Path.Split( "." );

						int endIndex = 0;

						string trmpString = string.Empty;

						if ( ss.Count() >= 2 )

						{
							if ( jt.Path.Contains( "[" ) )

							{
								endIndex = ss[ss.Length - 2].ToString().IndexOf( "[" );

								trmpString = ss[ss.Length - 2].ToString().Substring( 0, endIndex );
							}else  {
								endIndex = 0;

								trmpString = ss[ss.Length - 2].ToString();
							}
						}else  {
							endIndex = 0;

							trmpString = "root";
						}

						if ( trmpString == s.Split( "." ).Last() )

						{
							if ( !tbname[s].Columns.Contains( ss.Last() ) )

								tbname[s].Columns.Add( ss.Last() );

							int RowIndex = Convert.ToInt32( trmpString.Replace( s.Split( "." ).Last(), "" ).Replace( "[", "" ).Replace( "]", "" ).Length > 0

											? trmpString.Replace( s.Split( "." ).Last(), "" ).Replace( "[", "" ).Replace( "]", "" ) : "0" );

							if ( tbname[s].Rows.Count < RowIndex + 1 )

								tbname[s].Rows.Add();

							tbname[s].Rows[RowIndex][ss.Last()] = jt;
						}
					}
				}
			}
		}

		return(RecursiveAsync( sss ) );
	}
}