C# JSON格式序列化与反序列化类

using Newtonsoft.Json;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Data;
using System.Reflection;
using System.Text.RegularExpressions;
using System.Web.Script.Serialization;

namespace SY_XSJ
{
    /// <summary>
    /// JSON格式序列化与反序列化类
    /// </summary>
    public sealed class Serializer
    {
        #region 私有方法
        /// <summary>
        /// 序列化DataTable
        /// </summary>
        /// <param name="dt"></param>
        /// <returns></returns>
        private static List<Dictionary<string, object>> Serialize(DataTable dt)
        {
            List<Dictionary<string, object>> rows = new List<Dictionary<string, object>>();
            foreach (DataRow dr in dt.Rows)
            {
                Dictionary<string, object> row = new Dictionary<string, object>();
                foreach (DataColumn dc in dt.Columns)
                {
                    row.Add(dc.ColumnName, dr[dc.ColumnName]);
                }
                rows.Add(row);
            }
            return rows;
        }

        /// <summary>
        /// 序列化NameValueCollection
        /// </summary>
        /// <param name="collection"></param>
        /// <param name="serializer"></param>
        /// <returns></returns>
        private static string Serialize(NameValueCollection collection, JavaScriptSerializer serializer)
        {
            IDictionary<string, string> keyValues = new Dictionary<string, string>();
            for (int i = 0; i < collection.Count; i++)
            {
                keyValues.Add(collection.Keys[i], collection[i]);
            }
            return serializer.Serialize(keyValues);
        }

        /// <summary>
        /// 序列化Hashtable
        /// </summary>
        /// <param name="hashtable"></param>
        /// <param name="serializer"></param>
        /// <returns></returns>
        private static string Serialize(Hashtable hashtable, JavaScriptSerializer serializer)
        {
            IDictionary<string, object> keyValues = new Dictionary<string, object>();
            foreach (DictionaryEntry entry in hashtable)
            {
                keyValues.Add(entry.Key.ToString(), entry.Value);
            }
            return serializer.Serialize(keyValues);
        }

        /// <summary>
        /// 反序列化DataTable
        /// </summary>
        /// <param name="json">josn数据</param>
        /// <param name="serializer"></param>
        /// <returns></returns>
        private static DataTable Deserialize2DataTable(string json, JavaScriptSerializer serializer)
        {
            var obj = serializer.DeserializeObject(json);
            object[] data = obj as object[];
            DataTable dt = new DataTable();
            foreach (IDictionary<string, object> row in data)
            {
                if (dt.Columns.Count == 0)
                {
                    foreach (string key in row.Keys)
                    {
                        dt.Columns.Add(key);
                    }
                }
                DataRow dr = dt.NewRow();

                //为行中的每一列列赋值
                foreach (string keyname in row.Keys)
                {
                    dr[keyname] = row[keyname];
                }
                dt.Rows.Add(dr);
            }
            return dt;
        }

        /// <summary>
        /// 反序列化NameValueCollection
        /// </summary>
        /// <param name="json">josn数据</param>
        /// <param name="serializer"></param>
        /// <returns></returns>
        private static NameValueCollection Deserialize2NameValueCollection(string json, JavaScriptSerializer serializer)
        {
            NameValueCollection nv = new NameValueCollection();
            if (string.IsNullOrEmpty(json))
            {
                return nv;
            }
            var obj = serializer.DeserializeObject(json);
            IDictionary<string, object> keyValues = obj as IDictionary<string, object>;
            foreach (KeyValuePair<string, object> entry in keyValues)
            {
                nv.Add(entry.Key, entry.Value.GetString());
            }
            return nv;
        }

        /*****
         * JSON格式不直接支持日期和时间。
         * DateTime值值显示为“/Date(700000+0500)/”形式的JSON字符串，
         * 其中第一个数字（在提供的示例中为 700000）是 GMT 时区中自 1970 年 1 月 1 日午夜以来按正常时间（非夏令时）经过的毫秒数。
         * 该数字可以是负数，以表示之前的时间。
         * 示例中包括“+0500”的部分可选，它指示该时间属于Local类型，即它在反序列化时应转换为本地时区。如果没有该部分，则会将时间反序列化为Utc。
         * **/

        /// <summary>
        /// 将Json序列化的时间由/Date(1294499956278+0800)转为字符串
        /// </summary>
        private static string ConvertJsonDateToDateString(Match m)
        {
            string result = string.Empty;
            DateTime dt = new DateTime(1970, 1, 1);
            dt = dt.AddMilliseconds(long.Parse(m.Groups[1].Value));
            dt = dt.ToLocalTime();
            result = dt.ToString("yyyy-MM-dd HH:mm:ss");
            return result;
        }

        /// <summary>
        /// 将时间字符串转为Json时间
        /// </summary>
        private static string ConvertDateStringToJsonDate(Match m)
        {
            string result = string.Empty;
            DateTime dt = DateTime.Parse(m.Groups[0].Value);
            dt = dt.ToUniversalTime();
            TimeSpan ts = dt - DateTime.Parse("1970-01-01");
            result = string.Format("\\/Date({0})\\/", ts.TotalMilliseconds);
            return result;
        }
        #endregion

        /// <summary>
        /// 将实体对象或DataTable序列化成JSON格式
        /// </summary>
        /// <param name="item">实体对象（集合）或DataTable</param>
        /// <returns>json格式字符串</returns>
        public static string Serialize(object item)
        {
            if (item == null
                || item == DBNull.Value
                || string.IsNullOrEmpty(item.ToString()))
            {
                return string.Empty;
            }

            string json = string.Empty;
            Type type = item.GetType();
            JavaScriptSerializer serialObj = new JavaScriptSerializer();
            serialObj.MaxJsonLength = 2097152 * 5;//默认4M，现调整为20M
            if (item.GetType() == typeof(DataTable))
            {
                json = serialObj.Serialize(Serialize(item as DataTable));
            }
            else if (item.GetType() == typeof(NameValueCollection))
            {
                json = Serialize(item as NameValueCollection, serialObj);
            }
            else if (item.GetType() == typeof(Hashtable))
            {
                json = Serialize(item as Hashtable, serialObj);
            }
            else
            {
                try
                {
                    json = serialObj.Serialize(item);
                }
                catch (Exception ex)
                {
                    json = JsonConvert.SerializeObject(item);
                    //TODO：错误日志
                }
            }

            if (!string.IsNullOrEmpty(json))
            {
                //替换Json的Date字符串
                string p = @"\\/Date\((.*?)\)\\/";
                MatchEvaluator matchEvaluator = new MatchEvaluator(ConvertJsonDateToDateString);
                Regex reg = new Regex(p);
                return reg.Replace(json, matchEvaluator);
            }
            return string.Empty;
        }

        /// <summary>
        /// 将json格式字符串转换成实体对象
        /// </summary>
        /// <typeparam name="T">实体对象类型</typeparam>
        /// <param name="json">json格式字符串</param>
        /// <param name="isCatch">是否捕获异常</param>
        /// <returns>实体对象</returns>
        public static T Deserialize<T>(string json, bool isCatch = true) where T : class
        {
            if (string.IsNullOrEmpty(json))
            {
                return null;
            }
            if (typeof(T) == typeof(DataTable))
            {
                return JsonConvert.DeserializeObject<T>(json);
            }
            JavaScriptSerializer serialObj = new JavaScriptSerializer();
            serialObj.MaxJsonLength = 2097152 * 20;//默认4M，现调整为20M
            if (typeof(T) == typeof(NameValueCollection))
            {
                return (T)(Deserialize2NameValueCollection(json, serialObj) as object);
            }
            if (isCatch)
            {
                T obj = null;
                try
                {
                    obj = serialObj.Deserialize<T>(json);
                }
                catch (Exception ex)
                {
                    //TODO：错误日志
                }
                return obj;
            }
            return serialObj.Deserialize<T>(json);
        }

        /// <summary>
        /// 将json格式字符串转换成实体对象
        /// </summary>
        /// <typeparam name="T">实体对象类型</typeparam>
        /// <param name="json">json格式字符串</param>
        /// <returns>实体对象</returns>
        public static T Deserialize<T>(string json) where T : class
        {
            if (string.IsNullOrEmpty(json))
            {
                return null;
            }
            if (typeof(T) == typeof(DataTable))
            {
                return JsonConvert.DeserializeObject<T>(json);
            }
            JavaScriptSerializer serialObj = new JavaScriptSerializer();
            serialObj.MaxJsonLength = 2097152 * 20;//默认4M，现调整为20M
            if (typeof(T) == typeof(NameValueCollection))
            {
                return (T)(Deserialize2NameValueCollection(json, serialObj) as object);
            }

            T obj = null;
            try
            {
                obj = serialObj.Deserialize<T>(json);
            }
            catch (Exception ex)
            {
                //TODO：错误日志
                return obj;
            }
            return obj;
        }

        /// <summary>
        /// 深复制
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="obj"></param>
        /// <returns></returns>
        public static T DeepCopy<T>(object obj) where T : class
        {
            string json = Serializer.Serialize(obj);
            return Serializer.Deserialize<T>(json);
        }

        #region JSON空转换处理
        /// <summary>
        /// 将属性为NULL的改为空字符串
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public static object ConverNullToEmptyString(object obj)
        {
            if (obj == null)
            {
                return obj;
            }

            if (IsArrayORListType(obj.GetType().FullName))
            {
                ConverNullToEmptyString_List(obj);
            }
            else
            {
                ConverNullToEmptyString_Single(obj);
            }
            return obj;
        }

        /// <summary>
        /// 将属性为NULL的改为空字符串
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        private static void ConverNullToEmptyString_Single(object obj)
        {
            if (obj == null)
            {
                return;
            }

            foreach (PropertyInfo pi in obj.GetType().GetProperties())
            {
                if (IsNullString(pi, obj)
                    && pi.CanWrite)
                {
                    pi.SetValue(obj, "", null);
                    continue;
                }
                else if (IsArrayORListType(pi.PropertyType.FullName))
                {
                    object value_Old = pi.GetValue(obj, null);
                    ConverNullToEmptyString_List(value_Old);
                }
            }
        }

        /// <summary>
        /// 
        /// </summary>
        private static void ConverNullToEmptyString_List(object listObject)
        {
            if (listObject == null)
            {
                return;
            }
            IList list = listObject as IList;
            for (int i = 0; i < list.Count; i++)
            {
                ConverNullToEmptyString_Single(list[i]);
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="fullName"></param>
        /// <returns></returns>
        private static bool IsArrayORListType(string fullName)
        {
            if (fullName.Contains("AnonymousType"))
                return false;

            return fullName.Contains("System.Collections.Generic.List");
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="pi"></param>
        /// <param name="obj"></param>
        /// <returns></returns>
        private static bool IsNullString(PropertyInfo pi, object obj)
        {
            return pi.PropertyType == typeof(string)
                        && pi.GetValue(obj, null) == null;
        }
        #endregion
    }
}