json 转换

using System;
using System.Collections.Generic;
using System.Data;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
using System.Text;
using System.Xml;
using System.Web;
using System.Web.Script.Serialization;
using System.Runtime.Serialization.Json;
using System.Xml.Serialization;
using System.Text.RegularExpressions;

namespace Maticsoft.COM
{
    /// <summary>
    /// 数据转换类
    /// </summary>
    public static class Transform
    {

        /// <summary>
        /// json序列化（非二进制方式）
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="t"></param>
        /// <returns></returns>
        public static string JsonSerializer<T>(T t)
        {
            JavaScriptSerializer jsonSerialize = new JavaScriptSerializer();
            return jsonSerialize.Serialize(t);
        }
        /// <summary>
        /// 把对象转换成Json格式的字符串
        /// </summary>
        /// <param name="o">对象</param>
        /// <returns>返回Json格式的字符串</returns>
        public static string ToJsonString(Object o)
        {
            JavaScriptSerializer script = new JavaScriptSerializer();
            string str = script.Serialize(o);
            //处理日期格式转换的问题
            str = Regex.Replace(str, @"\/Date((d+))\/", match =>
            {
                DateTime dt = new DateTime(1970, 1, 1);
                dt = dt.AddMilliseconds(long.Parse(match.Groups[1].Value));
                dt = dt.ToLocalTime();
                return dt.ToString("yyyy-MM-dd HH:mm:ss");
            });
            return str;
        }

        /// <summary>
        /// 把DataSet转换成Json格式的字符串
        /// </summary>
        /// <param name="dataset">DataSet数据集</param>
        /// <returns>返回Json格式的字符串</returns>
        public static string ToJsonString(DataSet dataset)
        {
            List<List<Dictionary<string, string>>> m_list = new List<List<Dictionary<string, string>>>();
            foreach (DataTable dt in dataset.Tables)
            {

                List<Dictionary<string, string>> m_table = new List<Dictionary<string, string>>();
                foreach (DataRow dr in dt.Rows)
                {
                    Dictionary<string, string> m_row = new Dictionary<string, string>();
                    foreach (DataColumn dc in dt.Columns)
                    {
                        m_row.Add(dc.ColumnName, dr[dc].ToString());
                    }
                    m_table.Add(m_row);
                }
                m_list.Add(m_table);
            }
            return ToJsonString(m_list);
        }

        /// <summary>
        /// 把XmlDocument对象转换成Json格式的字符串
        /// </summary>
        /// <param name="doc">XmlDocument对象</param>
        /// <returns>返回Json格式的字符串</returns>
        public static string ToJsonString(XmlDocument doc)
        {
            XmlNodeList oNodes = doc.DocumentElement.ChildNodes;
            List<Dictionary<string, string>> m_List = new List<Dictionary<string, string>>();
            foreach (XmlNode oNode in oNodes)
            {
                Dictionary<string, string> dir = new Dictionary<string, string>();
                foreach (XmlAttribute Attr in oNode.Attributes)
                {
                    dir.Add(Attr.Name, Attr.Value);
                }
                m_List.Add(dir);
            }
            return ToJsonString(m_List);
        }

        /// <summary>
        /// 把DataTable对象转换成Json格式的字符串
        /// </summary>
        /// <param name="datatable">DataTable对象</param>
        /// <returns>返回Json格式的字符串</returns>
        public static string ToJsonString(DataTable datatable)
        {
            List<Dictionary<string, string>> m_table = new List<Dictionary<string, string>>();
            foreach (DataRow dr in datatable.Rows)
            {
                Dictionary<string, string> m_row = new Dictionary<string, string>();
                foreach (DataColumn dc in datatable.Columns)
                {
                    m_row.Add(dc.ColumnName, dr[dc].ToString());
                }
                m_table.Add(m_row);
            }
            return ToJsonString(m_table);
        }

        /// <summary>
        /// Json格式的字符串转换成指定类型的对象
        /// </summary>
        /// <param name="JsonString">son格式的字符串</param>
        /// <param name="t">转换的类型</param>
        /// <returns>转换后的对象</returns>
        public static object parseJSON(string JsonString, Type t)
        {
            object o = null;
            MemoryStream stream1 = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(JsonString));
            DataContractJsonSerializer dataSer = new DataContractJsonSerializer(t);
            try
            {
                o = dataSer.ReadObject(stream1);
            }
            catch (Exception eorr)
            {
                throw eorr;
            }
            finally
            {
                stream1.Close();
                stream1.Dispose();
            }

            return o;
        }

        /// <summary>
        /// Json格式的字符串转换成指定类型的对象
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="JsonString"></param>
        /// <returns></returns>
        public static T JSONToObject<T>(string JsonString)
        {
            JavaScriptSerializer jss = new JavaScriptSerializer();
            try
            {
                return jss.Deserialize<T>(JsonString);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        /// <summary>
        /// 转换成xml字符串
        /// </summary>
        /// <param name="type">对象类型</param>
        /// <param name="o">转换的对象</param>
        /// <returns></returns>
        public static string ObjectToXmlString(Type type, object o)
        {
            return ObjectToXmlDocument(type, o).OuterXml;
        }

        /// <summary>
        /// 转换成xml对象
        /// </summary>
        /// <param name="type">对象类型</param>
        /// <param name="o">转换的对象</param>
        /// <returns></returns>
        public static XmlDocument ObjectToXmlDocument(Type type, object o)
        {
            XmlSerializer mySerializer = new XmlSerializer(type);
            Stream oStream = new MemoryStream();
            StreamWriter stream = new StreamWriter(oStream);
            mySerializer.Serialize(stream, o);
            oStream.Position = 0;
            TextReader textReader = new StreamReader(oStream);
            XmlDocument doc = new XmlDocument();
            doc.Load(textReader);
            stream.Close();
            return doc;
        }

        /// <summary>
        /// 转换字符串为GUID
        /// </summary>
        /// <param name="sVal">字符串</param>
        /// <returns>GUID对象</returns>
        public static object GetDBGUIDVal(string sVal)
        {
            object ob = null;
            if (string.IsNullOrEmpty(sVal))
            {
                ob = DBNull.Value;
            }
            else
            {
                Guid g = new Guid(sVal);
                return g;
            }
            return ob;
        }

        /// <summary>
        /// 转换GUID为object
        /// </summary>
        /// <param name="gVal">GUID</param>
        /// <returns>GUID对象</returns>
        public static object GetDBGUIDVal(Guid gVal)
        {
            object ob = null;
            if (gVal == Guid.Empty || gVal == null)
            {
                ob = DBNull.Value;
            }
            else
            {
                return gVal;
            }
            return ob;
        }

        /// <summary>
        /// 转换DateTime为数据字段类型
        /// </summary>
        /// <returns></returns>
        public static object GetDBDateTime(DateTime dt)
        {
            object ob = null;
            if (dt == null)
                ob = DBNull.Value;
            else
                return dt;
            return ob;
        }

        /// <summary>
        /// 获取object的布尔值
        /// </summary>
        /// <param name="ov"></param>
        /// <returns></returns>
        public static bool GetBoolValue(object ov)
        {
            if (ov == null)
                return false;
            if (ov.ToString().Equals("1"))
                return true;
            if (ov.ToString().Equals("true"))
                return true;
            if (ov.ToString().Equals("True"))
                return true;
            return false;
        }

        /// <summary>
        /// 获取string的布尔值
        /// </summary>
        /// <param name="ov"></param>
        /// <returns></returns>
        public static bool GetBoolValue(string sv)
        {
            if (sv.Equals("1"))
                return true;
            if (sv.ToLower().Equals("true"))
                return true;
            return false;
        }
        /// <summary>
        /// 将对象属性转换为key-value对
        /// </summary>   
        /// <param name="o"></param>   
        /// <returns></returns>   
        public static Dictionary<String, Object> ToPropDictionary(Object o)
        {
            Dictionary<String, Object> map = new Dictionary<string, object>();
            Type t = o.GetType();
            PropertyInfo[] pi = t.GetProperties(BindingFlags.Public | BindingFlags.Instance);
            foreach (PropertyInfo p in pi)
            {
                MethodInfo mi = p.GetGetMethod();

                if (mi != null && mi.IsPublic)
                {
                    try
                    {
                        map.Add(p.Name, mi.Invoke(o, new Object[] { }));
                    }
                    catch (Exception e)
                    {
                    }
                }
            }

            return map;
        }

        /// <summary>
        /// 把DataTable对象转换成TreeGrid支持的Json格式字符串
        /// </summary>
        /// <param name="datatable">DataTable对象</param>
        /// <param name="CurrField">主键</param>
        /// <param name="ParentField">父级主键</param>
        /// <returns>返回Json格式的字符串</returns>
        public static string ToJsonStringForTreeList(DataTable datatable, string CurrField, string ParentField, string IdValue)
        {
            List<Dictionary<string, string>> m_table = new List<Dictionary<string, string>>();
            //DataRow[] aryDr = datatable.Select(string.Format(ParentField+" is null");
            DataRow[] aryDr = datatable.Select(string.Format("ID='{0}'", IdValue));
            foreach (DataRow dr in aryDr)
            {
                string ParACode = string.Empty;
                Dictionary<string, string> m_row = new Dictionary<string, string>();
                foreach (DataColumn dc in datatable.Columns)
                {
                    m_row.Add(dc.ColumnName, dr[dc].ToString());
                }

                //判断是否有子级节点
                ParACode = dr[CurrField].ToString();
                if (!string.IsNullOrEmpty(ParACode))
                {
                    getSubDic(datatable, ParentField, ParACode, ref m_row, CurrField);
                }
                m_table.Add(m_row);
            }
            return ToJsonString(m_table);
        }
        private static void getSubDic(DataTable datatable,
            string ParentField,
            string ParentCode,
            ref Dictionary<string, string> parentDic,
            string CurrField)
        {
            DataRow[] arySubDr = datatable.Select(string.Format("{1}='{0}'", ParentCode, ParentField));
            if (arySubDr.Length != 0)
            {
                List<string> subDic = new List<string>();
                foreach (DataRow dr in arySubDr)
                {
                    Dictionary<string, string> subRowDic = new Dictionary<string, string>();
                    foreach (DataColumn dc in datatable.Columns)
                    {
                        subRowDic.Add(dc.ColumnName, dr[dc].ToString());
                    }
                    //判断是否有子级节点
                    if (!string.IsNullOrEmpty(dr[CurrField].ToString()))
                    {
                        getSubDic(datatable, ParentField, dr[CurrField].ToString(), ref subRowDic, CurrField);
                    }
                    subDic.Add(ToJsonString(subRowDic));
                }
                parentDic.Add("state", "closed");
                parentDic.Add("children", ToJsonString(subDic));
            }
        }
        /// <summary>
        /// 将一个object对象序列化，返回一个byte[]
        /// </summary>
        /// <param name="obj">能序列化的对象</param>
        /// <returns></returns>
        public static byte[] ObjectToBytes(object obj)
        {
            using (MemoryStream ms = new MemoryStream())
            {
                IFormatter formatter = new BinaryFormatter();
                formatter.Serialize(ms, obj);
                return ms.GetBuffer();
            }
        }
        #region 字符加密为MD5 Methods - Encode


        #endregion

        /// <summary>
        /// 过滤不安全的字符串
        /// </summary>
        /// <param name="Str"></param>
        /// <returns></returns>
        public static string FilteSQLStr(string Str)
        {

            Str = Str.Replace("delete", "");
            Str = Str.Replace("update", "");
            Str = Str.Replace("insert", "");
            Str = Str.Replace("drop", "");
            Str = Str.Replace("DELETE", "");
            Str = Str.Replace("UPDATE", "");
            Str = Str.Replace("INSERT", "");
            Str = Str.Replace("DROP", "");
            return Str;
        }
    }
}