将Json数据转换为实体类等方法的帮助类

时间 2019-11-21

原文原文链接

最新更新，平时使用的jsonHelper类，分享给你们使用。json

注：须要引用Json.Net类库。数组

public class JsonHelper
    {
        /// <summary>
        /// string扩展方法(忽略大小写比较字符串)
        /// </summary>
        /// <param name="source">源字符串</param>
        /// <param name="value">目标字符串</param>
        /// <param name="comparisonType"></param>
        public static bool Contains(string source, string value, StringComparison comparisonType = StringComparison.OrdinalIgnoreCase)
        {
            return source.IndexOf(value, comparisonType) >= 0;
        }
        /// <summary> 
        /// 对象转JSON 
        /// </summary> 
        /// <param name="obj">对象</param> 
        /// <returns>JSON格式的字符串</returns> 
        public static string ObjectToJson(object obj)
        {
            try
            {
                return Newtonsoft.Json.JsonConvert.SerializeObject(obj);
            }
            catch (Exception ex)
            {
                throw new Exception(string.Format("JSONHelper.ObjectToJSON()异常:{0} 数据:{1} ", ex.Message, obj));
            }
        }
        /// <summary>
        /// 获取Json格式返回结果
        /// </summary>
        /// <param name="result">操做结果返回类型</param>
        /// <param name="data">返回数据</param>
        /// <param name="msg">结果描述</param>
        /// <returns>Json格式数据，形如{"result":1,"data":0,"msg":""}</returns>
        public static string GetJsonResult(BackType result, object data, string msg)
        {
            var dic = new Dictionary<string, object>();
            dic.Add(JsonItem.Result, result.GetHashCode());
            dic.Add(JsonItem.Data, data);
            dic.Add(JsonItem.Msg, msg);

            return ObjectToJson(dic);
        }
        /// <summary>
        /// 输出成功数据
        /// </summary>
        /// <param name="data">返回数据</param>
        /// <param name="msg">返回信息</param>
        public static void ResponseOK(System.Web.HttpContext cnt, object data, string msg = "请求成功")
        {
            var json = GetJsonResult(BackType.Success, data, msg);
            cnt.Response.Write(json);
        }
        /// <summary>
        /// 输出失败数据
        /// </summary>
        /// <param name="data">返回数据</param>
        /// <param name="msg">返回信息</param>
        public static void ResponseFail(System.Web.HttpContext cnt, object data, string msg)
        {
            var json = GetJsonResult(BackType.Failure, data, msg);
            cnt.Response.Write(json);
        }
        /// <summary>
        /// 输出验证错误数据
        /// </summary>
        /// <param name="data">返回数据</param>
        /// <param name="msg">返回信息</param>
        public static void ResponseErr(System.Web.HttpContext cnt, object data, string msg)
        {
            var json = GetJsonResult(BackType.CheckErr, data, msg);
            cnt.Response.Write(json);
        }
        /// <summary>
        /// DataTable转数组集合（输出字段名全小写）
        /// </summary>
        /// <param name="dt">数据表</param>
        /// <returns>符合Json格式转换数据集</returns>
        public static Dictionary<string, object> DataTableToDic(DataTable dt)
        {
            var dic = new Dictionary<string, object>();
            var list = new List<object>();
            if (dt != null)
            {
                var rows = dt.Rows.Count;
                var cols = dt.Columns.Count;
                dic.Add(JsonItem.Count, rows);//总记录数
                for (int i = 0; i < rows; i++)
                {
                    var row = new Dictionary<string, object>();
                    for (int j = 0; j < cols; j++)
                    {
                        row.Add(dt.Columns[j].ColumnName.ToLower(), dt.Rows[i][j]);
                    }
                    list.Add(row);
                }
            }
            else
            {
                dic.Add(JsonItem.Count, 0);
            }
            dic.Add(JsonItem.List, list);//数据列表

            return dic;
        }
        /// <summary>
        /// DataTable转Json格式（输出字段名全小写）
        /// </summary>
        /// <param name="dt">数据表</param>
        /// <returns>Json格式数据，形如：{"result":1,"data":{"count":0,"list":[{},{}]},"msg":"成功"}</returns>
        public static string DataTableToJson(DataTable dt)
        {
            if (dt == null || dt.Rows.Count < 1)
            {
                return GetJsonResult(BackType.Failure, "", "数据为空");
            }
            return GetJsonResult(BackType.Success, DataTableToDic(dt), "请求成功");
        }
        /// <summary>
        /// DataSet转Json格式（输出字段名全小写）
        /// </summary>
        /// <param name="ds">数据集</param>
        /// <returns>Json格式数据，形如：{"result":1,"data":[{"count":0,"list":[{},{}]},{}],"msg":""}</returns>
        public static string DataSetToJson(DataSet ds)
        {
            if (ds == null || ds.Tables.Count < 1)
            {
                return GetJsonResult(BackType.Failure, "", "数据为空");
            }
            var tbs = new List<object>();
            for (int i = 0; i < ds.Tables.Count; i++)
            {
                tbs.Add(DataTableToDic(ds.Tables[i]));
            }

            return GetJsonResult(BackType.Success, tbs, "table数目：" + tbs.Count);
        }
        /// <summary>
        /// 将实体转换为Dictionary
        /// </summary>
        /// <typeparam name="T">实体类</typeparam>
        /// <param name="info">实体实例</param>
        /// <returns></returns>
        public static Dictionary<string, object> EntityToDic<T>(T info) where T : class
        {
            var dic = new Dictionary<string, object>();
            if (info != null)
            {
                var type = typeof(T);
                var fields = type.GetProperties();//实体属性集合

                foreach (var p in fields)
                {
                    dic.Add(p.Name, p.GetValue(info, null));
                }
            }
            return dic;
        }
        /// <summary>
        /// 将实体转换为Hashtable
        /// </summary>
        /// <typeparam name="T">实体类</typeparam>
        /// <param name="info">实体实例</param>
        /// <returns></returns>
        public static Hashtable EntityToHashtable<T>(T info) where T : class
        {
            var ht = new Hashtable();
            if (info != null)
            {
                var type = typeof(T);
                var fields = type.GetProperties();//实体属性集合

                foreach (var p in fields)
                {
                    ht.Add(p.Name, p.GetValue(info, null));
                }
            }
            return ht;
        }
        /// <summary>
        /// Hashtable转化为实体
        /// </summary>
        /// <typeparam name="T">实体类型</typeparam>
        /// <param name="ht">Hashtable数据</param>
        public static T HashtableToEntity<T>(Hashtable ht) where T : class
        {
            var type = typeof(T);
            var fields = type.GetProperties();//实体属性集合
            var info = (T)GetInstance(type);//构建实例

            foreach (var p in fields)//为实体实例赋值
            {
                if (ht.Count < 1) break;
                var key = p.Name;
                if (ht.ContainsKey(key))
                {
                    var ovalue = ht[key];
                    ht.Remove(ovalue);
                    if (ovalue == null || ovalue == DBNull.Value) continue;

                    var ptype = GetStandardType(p.PropertyType);
                    p.SetValue(info, Convert.ChangeType(ovalue, ptype), null);
                }
            }
            return info;
        }
        /// <summary>
        /// 类型转换字典
        /// </summary>
        private static Dictionary<Type, Type> TypeDic = new Dictionary<Type, Type>{{typeof(bool?),typeof(bool)},{typeof(int?),typeof(int)},
            {typeof(long?),typeof(long)},{typeof(decimal?),typeof(decimal)},{typeof(DateTime?),typeof(DateTime)} };
        /// <summary>
        /// 获取标准类型
        /// </summary>
        public static Type GetStandardType(Type t)
        {
            if (TypeDic.ContainsKey(t))
            {
                t = TypeDic[t];
            }
            return t;
        }

        /// <summary>
        /// Json数据转实体
        /// </summary>
        /// <typeparam name="T">实体类型</typeparam>
        /// <param name="json">Json数据</param>
        /// <returns></returns>
        public static T JsonToEntity<T>(string json)
        {
            var type = typeof(T);
            var fields = type.GetProperties();//实体属性集合
            var info = (T)GetInstance(type);//构建实例
            try
            {
                var obj = (Newtonsoft.Json.Linq.JObject)Newtonsoft.Json.JsonConvert.DeserializeObject(json);
                var list = obj.Properties();
                foreach (var p in fields)//为实体实例赋值
                {
                    var item = list.FirstOrDefault(tp => string.Compare(tp.Name, p.Name, true) == 0);
                    if (item != null && item.Value != null)
                    {
                        var val = item.Value.ToString();
                        if (String.IsNullOrEmpty(val) || val == "null") continue;

                        var ptype = GetStandardType(p.PropertyType);
                        p.SetValue(info, Convert.ChangeType(val, ptype), null);
                    }
                }
            }
            catch (Exception ex)
            {
                TxtLog.LogErr("Json转实体解析异常：" + ex.Message);
            }
            return info;
        }

        /// <summary>
        /// json数据转字典
        /// </summary>
        /// <param name="json">Json数据</param>
        public static Dictionary<string, object> JsonToDic(string json)
        {
            var dic = new Dictionary<string, object>();
            try
            {
                var obj = (Newtonsoft.Json.Linq.JObject)Newtonsoft.Json.JsonConvert.DeserializeObject(json);
                var list = obj.Properties();
                foreach (var item in list)
                {
                    dic.Add(item.Name, item.Value);
                }
            }
            catch (Exception ex)
            {
                TxtLog.LogErr("Json转Dic解析异常：" + ex.Message);
            }
            return dic;
        }
        #region 实例工具方法
        /// <summary>
        /// 实体克隆方法
        /// </summary>
        private static MethodInfo wiseClone = typeof(object).GetMethod("MemberwiseClone", BindingFlags.NonPublic | BindingFlags.Instance);
        /// <summary>
        /// 实体克隆委托方法
        /// </summary>
        private static Func<object, object> doClone = Delegate.CreateDelegate(typeof(Func<object, object>), wiseClone) as Func<object, object>;
        /// <summary>
        /// 对象实例缓存
        /// </summary>
        private static System.Collections.Concurrent.ConcurrentDictionary<string, object> TCache = new System.Collections.Concurrent.ConcurrentDictionary<string, object>();
        /// <summary>
        /// 缓存操做锁
        /// </summary>
        private static object lockCache = new object();
        /// <summary>
        /// 获取对象实例
        /// </summary>
        /// <param name="type">对象类型</param>
        public static object GetInstance(Type type)
        {
            object obj;
            if (!TCache.TryGetValue(type.Name, out obj))
            {
                obj = Activator.CreateInstance(type);//构建实例
                lock (lockCache)
                {
                    TCache.TryAdd(type.Name, obj);
                }
            }
            return doClone(obj);
        }
        #endregion
    }

帮助类中用的的两个辅助类代码：缓存

/// <summary>
    /// 结果返回类型
    /// </summary>
    public enum BackType
    {
        /// <summary>
        /// 验证错误 -1
        /// </summary>
        CheckErr = -1,
        /// <summary>
        /// 失败 0
        /// </summary>
        Failure = 0,
        /// <summary>
        /// 成功 1
        /// </summary>
        Success = 1,
    }

/// <summary>
    /// JSON数据格式字段
    /// </summary>
    public class JsonItem
    {
        /// <summary>
        /// 结果标识字段
        /// </summary>
        public const string Result = "result";
        /// <summary>
        /// 返回数据字段
        /// </summary>
        public const string Data = "data";
        /// <summary>
        /// 返回信息字段
        /// </summary>
        public const string Msg = "msg";
        /// <summary>
        /// 返回数据--数目字段
        /// </summary>
        public const string Count = "count";
        /// <summary>
        /// 返回数据--列表字段
        /// </summary>
        public const string List = "list";
    }