各种类型（object、list、dataTable）转json源码

using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.HtmlControls;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.IO;
using System.Text;
using System.Text.RegularExpressions;
using System.Web.Script.Serialization;
using System.Collections.Generic;
using System.Runtime.Serialization;
using System.Collections;
using System.Reflection;
using System.Globalization;
using System.Xml;

public class JSONHelper
{
    /// <summary>
    /// DataTable转Json
    /// </summary>
    /// <param name="dtb"></param>
    /// <returns></returns>
    public static string Dtb2Json(DataTable dtb)
    {
        JavaScriptSerializer jss = new JavaScriptSerializer();
        ArrayList dic = new ArrayList();
        foreach (DataRow row in dtb.Rows)
        {
            Dictionary<string, object> drow = new Dictionary<string, object>();
            foreach (DataColumn col in dtb.Columns)
            {
                drow.Add(col.ColumnName, row[col.ColumnName]);
            }
            dic.Add(drow);
        }
        return jss.Serialize(dic);
    }

    /// <summary>
    /// Json转DataTable
    /// </summary>
    /// <param name="json"></param>
    /// <returns></returns>
    public static DataTable Json2Dtb(string json)
    {
        JavaScriptSerializer jss = new JavaScriptSerializer();
        ArrayList dic = jss.Deserialize<ArrayList>(json);
        DataTable dtb = new DataTable();

        if (dic.Count > 0)
        {
            foreach (Dictionary<string, object> drow in dic)
            {
                if (dtb.Columns.Count == 0)
                {
                    foreach (string key in drow.Keys)
                    {
                        //if (drow[key].GetType() != null)
                        //    dtb.Columns.Add(key, drow[key].GetType());
                        //else
                        dtb.Columns.Add(key);
                    }
                }

                DataRow row = dtb.NewRow();
                foreach (string key in drow.Keys)
                {

                    row[key] = drow[key];
                }
                dtb.Rows.Add(row);
            }
        }
        return dtb;
    }

    public static string DataTable2Json(DataTable dt)
    {
        return DataTable2Json(dt, false);
    }
    /// <summary>
    /// DataTable2Json
    /// </summary>
    /// <param name="dt"></param>
    /// <param name="IsModel">是否实体类</param>
    /// <returns></returns>
    public static string DataTable2Json(DataTable dt, bool IsModel)
    {

        if (dt == null || dt.Rows.Count == 0)
            return "[]";
        StringBuilder jsonBuilder = new StringBuilder();

        if (dt.Rows.Count == 1 && IsModel == true)
        {
            #region 单条记录
            for (int i = 0; i < dt.Rows.Count; i++)
            {
                jsonBuilder.Append("{");
                for (int j = 0; j < dt.Columns.Count; j++)
                {
                    jsonBuilder.Append("\"");
                    jsonBuilder.Append(dt.Columns[j].ColumnName.ToLower());
                    jsonBuilder.Append("\":\"");
                    string value = dt.Rows[i][j].ToString().Replace("\r", "").Replace("\n", "").Replace("\t", "").Trim();
                    if (dt.Columns[j].DataType.FullName == "System.DateTime")
                        jsonBuilder.Append(value.Length == 0 ? value : Convert.ToDateTime(value).ToString("yyyy-MM-dd HH:mm:ss"));
                    else
                        jsonBuilder.Append(value);
                    jsonBuilder.Append("\",");
                }
                jsonBuilder.Remove(jsonBuilder.Length - 1, 1);
                jsonBuilder.Append("},");
            }
            jsonBuilder.Remove(jsonBuilder.Length - 1, 1);
            #endregion
        }
        else
        {
            #region 多条记录
            jsonBuilder.Append("[");
            for (int i = 0; i < dt.Rows.Count; i++)
            {
                jsonBuilder.Append("{");
                for (int j = 0; j < dt.Columns.Count; j++)
                {
                    jsonBuilder.Append("\"");
                    jsonBuilder.Append(dt.Columns[j].ColumnName.ToLower());
                    jsonBuilder.Append("\":\"");
                    string value = dt.Rows[i][j].ToString().Replace("\r", "").Replace("\n", "").Replace("\t", "").Trim();
                    if (dt.Columns[j].DataType.FullName == "System.DateTime")
                        jsonBuilder.Append(value.Length == 0 ? value : Convert.ToDateTime(value).ToString("yyyy-MM-dd"));
                    else
                        jsonBuilder.Append(value);
                    jsonBuilder.Append("\",");
                }
                jsonBuilder.Remove(jsonBuilder.Length - 1, 1);
                jsonBuilder.Append("},");
            }
            jsonBuilder.Remove(jsonBuilder.Length - 1, 1);
            jsonBuilder.Append("]");
            #endregion
        }
        return jsonBuilder.ToString();
    }

    #region JqueryEasyUI JSON  Method

    /// <summary>
    /// 将DataTable中的数据转换成JSON格式
    /// </summary>
    /// <param name="dt">数据源DataTable</param>
    /// <param name="displayCount">是否输出数据总条数</param>
    /// <returns></returns>
    public static string CreateJsonParameters(DataTable dt, bool displayCount)
    {
        return CreateJsonParameters(dt, displayCount, dt.Rows.Count);
    }
    /// <summary>
    /// 将DataTable中的数据转换成JSON格式
    /// </summary>
    /// <param name="dt">数据源DataTable</param>
    /// <returns></returns>
    public static string CreateJsonParameters(DataTable dt)
    {
        return CreateJsonParameters(dt, true);
    }
    /// <summary>
    /// 将DataTable中的数据转换成JSON格式 输出数据总条数,符合EasyUi数据格式要求
    /// </summary>
    /// <param name="dt">数据源DataTable</param>
    /// <param name="displayCount">是否输出数据总条数</param>
    /// <param name="totalcount">JSON中显示的数据总条数</param>
    /// <returns></returns>
    public static string CreateJsonParameters(DataTable dt, bool displayCount, int totalcount)
    {
        StringBuilder JsonString = new StringBuilder();
        //Exception Handling        

        if (dt != null)
        {
            JsonString.Append("{");
            JsonString.Append("\"rows\":[");
            for (int i = 0; i < dt.Rows.Count; i++)
            {
                JsonString.Append("{");
                for (int j = 0; j < dt.Columns.Count; j++)
                {
                    if (j < dt.Columns.Count - 1)
                    {
                        //if (dt.Rows[i][j] == DBNull.Value) continue;
                        if (dt.Columns[j].DataType == typeof(bool))
                        {
                            JsonString.Append("\"" + dt.Columns[j].ColumnName.ToLower().Trim() + "\":" +
                                              dt.Rows[i][j].ToString().ToLower().Trim() + ",");
                        }
                        else if (dt.Columns[j].DataType == typeof(string))
                        {
                            JsonString.Append("\"" + dt.Columns[j].ColumnName.ToLower().Trim() + "\":" + "\"" +
                                              dt.Rows[i][j].ToString().Trim().Replace("\"", "\\\"") + "\",");
                        }
                        else
                        {
                            JsonString.Append("\"" + dt.Columns[j].ColumnName.ToLower() + "\":" + "\"" + dt.Rows[i][j].ToString().Trim() + "\",");
                        }
                    }
                    else if (j == dt.Columns.Count - 1)
                    {
                        //if (dt.Rows[i][j] == DBNull.Value) continue;
                        if (dt.Columns[j].DataType == typeof(bool))
                        {
                            JsonString.Append("\"" + dt.Columns[j].ColumnName.ToLower() + "\":" +
                                              dt.Rows[i][j].ToString().ToLower().Trim());
                        }
                        else if (dt.Columns[j].DataType == typeof(string))
                        {
                            JsonString.Append("\"" + dt.Columns[j].ColumnName.ToLower() + "\":" + "\"" +
                                              dt.Rows[i][j].ToString().Replace("\"", "\\\"").Trim() + "\"");
                        }
                        else
                        {
                            JsonString.Append("\"" + dt.Columns[j].ColumnName.ToLower().Trim() + "\":" + "\"" + dt.Rows[i][j].ToString().Trim() + "\"");
                        }
                    }
                }
                /*end Of String*/
                if (i == dt.Rows.Count - 1)
                {
                    JsonString.Append("}");
                }
                else
                {
                    JsonString.Append("},");
                }
            }
            JsonString.Append("]");

            if (displayCount)
            {
                JsonString.Append(",");

                JsonString.Append("\"total\":");
                JsonString.Append(totalcount);
            }

            JsonString.Append("}");
            return JsonString.ToString().Replace("\n", "");
        }
        else
        {
            return null;
        }
    }

    #region object 2 json
    private static void WriteDataRow(StringBuilder sb, DataRow row)
    {
        sb.Append("{");
        foreach (DataColumn column in row.Table.Columns)
        {
            sb.AppendFormat("\"{0}\":", column.ColumnName);
            WriteValue(sb, row[column]);
            sb.Append(",");
        }
        // Remove the trailing comma.
        if (row.Table.Columns.Count > 0)
        {
            --sb.Length;
        }
        sb.Append("}");
    }

    private static void WriteDataSet(StringBuilder sb, DataSet ds)
    {
        sb.Append("{\"Tables\":{");
        foreach (DataTable table in ds.Tables)
        {
            sb.AppendFormat("\"{0}\":", table.TableName);
            WriteDataTable(sb, table);
            sb.Append(",");
        }
        // Remove the trailing comma.
        if (ds.Tables.Count > 0)
        {
            --sb.Length;
        }
        sb.Append("}}");
    }

    private static void WriteDataTable(StringBuilder sb, DataTable table)
    {
        sb.Append("{\"Rows\":[");
        foreach (DataRow row in table.Rows)
        {
            WriteDataRow(sb, row);
            sb.Append(",");
        }
        // Remove the trailing comma.
        if (table.Rows.Count > 0)
        {
            --sb.Length;
        }
        sb.Append("]}");
    }

    private static void WriteEnumerable(StringBuilder sb, IEnumerable e)
    {
        bool hasItems = false;
        sb.Append("[");
        foreach (object val in e)
        {
            WriteValue(sb, val);
            sb.Append(",");
            hasItems = true;
        }
        // Remove the trailing comma.
        if (hasItems)
        {
            --sb.Length;
        }
        sb.Append("]");
    }

    private static void WriteHashtable(StringBuilder sb, IDictionary e)
    {
        bool hasItems = false;
        sb.Append("{");
        foreach (string key in e.Keys)
        {
            sb.AppendFormat("\"{0}\":", key.ToLower());
            WriteValue(sb, e[key]);
            sb.Append(",");
            hasItems = true;
        }
        // Remove the trailing comma.
        if (hasItems)
        {
            --sb.Length;
        }
        sb.Append("}");
    }

    private static void WriteObject(StringBuilder sb, object o)
    {
        MemberInfo[] members = o.GetType().GetMembers(BindingFlags.Instance | BindingFlags.Public);
        sb.Append("{");
        bool hasMembers = false;
        foreach (MemberInfo member in members)
        {
            bool hasValue = false;
            object val = null;
            if ((member.MemberType & MemberTypes.Field) == MemberTypes.Field)
            {
                FieldInfo field = (FieldInfo)member;
                val = field.GetValue(o);
                hasValue = true;
            }
            else if ((member.MemberType & MemberTypes.Property) == MemberTypes.Property)
            {
                PropertyInfo property = (PropertyInfo)member;
                if (property.CanRead && property.GetIndexParameters().Length == 0)
                {
                    val = property.GetValue(o, null);
                    hasValue = true;
                }
            }
            if (hasValue)
            {
                sb.Append("\"");
                sb.Append(member.Name);
                sb.Append("\":");
                WriteValue(sb, val);
                sb.Append(",");
                hasMembers = true;
            }
        }
        if (hasMembers)
        {
            --sb.Length;
        }
        sb.Append("}");
    }

    private static void WriteString(StringBuilder sb, IEnumerable s)
    {
        sb.Append("\"");
        foreach (char c in s)
        {
            switch (c)
            {
                case '\"':
                    sb.Append("\\\"");
                    break;
                case '\\':
                    sb.Append("\\\\");
                    break;
                case '\b':
                    sb.Append("\\b");
                    break;
                case '\f':
                    sb.Append("\\f");
                    break;
                case '\n':
                    sb.Append("\\n");
                    break;
                case '\r':
                    sb.Append("\\r");
                    break;
                case '\t':
                    sb.Append("\\t");
                    break;
                default:
                    int i = c;
                    if (i < 32 || i > 127)
                    {
                        sb.AppendFormat("\\u{0:X04}", i);
                    }
                    else
                    {
                        sb.Append(c);
                    }
                    break;
            }
        }
        sb.Append("\"");
    }

    public static void WriteValue(StringBuilder sb, object val)
    {
        if (val == null || val == DBNull.Value)
        {
            sb.Append("null");
        }
        else if (val is string || val is Guid)
        {
            WriteString(sb, val.ToString());
        }
        else if (val is bool)
        {
            sb.Append(val.ToString().ToLower());
        }
        else if (val is double ||
                 val is float ||
                 val is long ||
                 val is int ||
                 val is short ||
                 val is byte ||
                 val is decimal)
        {
            sb.AppendFormat(CultureInfo.InvariantCulture.NumberFormat, "{0}", val);
        }
        else if (val.GetType().IsEnum)
        {
            sb.Append((int)val);
        }
        else if (val is DateTime)
        {
            //sb.Append("new Date(\"");
            //sb.Append(((DateTime)val).ToString("MMMM, d yyyy HH:mm:ss",new CultureInfo("en-US", false).DateTimeFormat));
            //sb.Append("\")");
            sb.Append("\"");
            sb.Append(((DateTime)val).ToString("yyyy-MM-dd HH:mm:ss"));
            sb.Append("\"");

        }
        else if (val is DataSet)
        {
            WriteDataSet(sb, val as DataSet);
        }
        else if (val is DataTable)
        {
            WriteDataTable(sb, val as DataTable);
        }
        else if (val is DataRow)
        {
            WriteDataRow(sb, val as DataRow);
        }
        else if (val is Hashtable)
        {
            WriteHashtable(sb, val as Hashtable);
        }
        else if (val is IEnumerable)
        {
            WriteEnumerable(sb, val as IEnumerable);
        }
        else
        {
            WriteObject(sb, val);
        }
    }

    /// <summary>
    /// 
    /// </summary>
    /// <param name="o"></param>
    /// <returns></returns>
    public static string Convert2Json(object o)
    {
        StringBuilder sb = new StringBuilder();
        WriteValue(sb, o);
        return sb.ToString();
    }

    #endregion
    #endregion
    /// <summary>
    /// 转换对象为JSON格式数据
    /// </summary>
    /// <typeparam name="T">类</typeparam>
    /// <param name="obj">对象</param>
    /// <returns>字符格式的JSON数据</returns>
    public static string GetJSON<T>(object obj)
    {
        string result = String.Empty;
        try
        {

            System.Runtime.Serialization.Json.DataContractJsonSerializer serializer =
            new System.Runtime.Serialization.Json.DataContractJsonSerializer(typeof(T));
            using (System.IO.MemoryStream ms = new System.IO.MemoryStream())
            {
                serializer.WriteObject(ms, obj);
                result = System.Text.Encoding.UTF8.GetString(ms.ToArray());
            }
        }
        catch (Exception ex)
        {
            throw ex;
        }
        return result;
    }
    /// <summary>
    /// 转换List<T>的数据为JSON格式
    /// </summary>
    /// <typeparam name="T">类</typeparam>
    /// <param name="vals">列表值</param>
    /// <returns>JSON格式数据</returns>
    public static string JSON<T>(List<T> vals)
    {
        System.Text.StringBuilder st = new System.Text.StringBuilder();
        try
        {
            System.Runtime.Serialization.Json.DataContractJsonSerializer s = new System.Runtime.Serialization.Json.DataContractJsonSerializer(typeof(T));

            foreach (T city in vals)
            {
                using (System.IO.MemoryStream ms = new System.IO.MemoryStream())
                {
                    s.WriteObject(ms, city);
                    st.Append(System.Text.Encoding.UTF8.GetString(ms.ToArray()));
                }
            }
        }
        catch (Exception ex)
        {
            throw ex;
        }

        return st.ToString();
    }
    /// <summary>
    /// JSON格式字符转换为T类型的对象
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="jsonStr"></param>
    /// <returns></returns>
    public static T ParseFormByJson<T>(string jsonStr)
    {
        T obj = Activator.CreateInstance<T>();
        using (System.IO.MemoryStream ms =
        new System.IO.MemoryStream(System.Text.Encoding.UTF8.GetBytes(jsonStr)))
        {
            System.Runtime.Serialization.Json.DataContractJsonSerializer serializer =
            new System.Runtime.Serialization.Json.DataContractJsonSerializer(typeof(T));
            return (T)serializer.ReadObject(ms);
        }
    }


    /// <summary>     
    /// dataTable转换成Json格式     
    /// </summary>     
    /// <param name="dt"></param>     
    /// <returns></returns>     
    public static string ToJson(DataTable dt)
    {
        StringBuilder jsonBuilder = new StringBuilder();
        jsonBuilder.Append("{\"");
        jsonBuilder.Append(dt.TableName);
        jsonBuilder.Append("\":[");
        for (int i = 0; i < dt.Rows.Count; i++)
        {
            jsonBuilder.Append("{");
            for (int j = 0; j < dt.Columns.Count; j++)
            {
                jsonBuilder.Append("\"");
                jsonBuilder.Append(dt.Columns[j].ColumnName);
                jsonBuilder.Append("\":\"");
                jsonBuilder.Append(dt.Rows[i][j].ToString());
                jsonBuilder.Append("\",");
            }
            jsonBuilder.Remove(jsonBuilder.Length - 1, 1);
            jsonBuilder.Append("},");
        }
        jsonBuilder.Remove(jsonBuilder.Length - 1, 1);
        jsonBuilder.Append("]");
        jsonBuilder.Append("}");
        return jsonBuilder.ToString();
    }

}