JsonHelper操作帮助类

四个主要操作类：JsonConverter、JsonHelper、JsonSplit、AjaxResult

一、JsonConverter：

自定义查询对象转换动态类、object动态类转换json包、json转换object动态类、DataReader转换为Json、DataSet转换为Json、DataTable转成Json、Datatable转换为Json、格式化字符型日期型布尔型、过滤特殊字符等

 

来自<http://www.cnblogs.com/yuangang/p/5468777.html>

 

using System;

usingSystem.Collections.Generic;

using System.Text;

using System.Data;

using System.Linq;

usingSystem.Web.Script.Serialization;

usingSystem.Collections;

 

namespace Common

{

    public class JsonConverter

    {

       

        /// <summary>

        ///自定义查询对象转换动态类

        /// add yuangang by 2015-05-19

        /// </summary>

        /// <paramname="obj"></param>

        /// <returns></returns>

        public static dynamic JsonClass(objectobj)

        {

            return ConvertJson(Serialize(obj,true));

        }

 

        /// <summary>

        /// object动态类转换json包

        /// add yuangang by 2015-05-19

        /// </summary>

        /// <param name="obj">对象</param>

        /// <paramname="DateConvert">时间戳是否转换成日期类型</param>

        /// <returns></returns>

        public static string Serialize(objectobj, bool DateConvert = false)

        {

            JavaScriptSerializer jss = newJavaScriptSerializer();

            var str = jss.Serialize(obj);

            if (DateConvert)

            {

                str =System.Text.RegularExpressions.Regex.Replace(str,@"\\/Date\((\d+)\)\\/", match =>

                {

                    DateTime dt = newDateTime(1970, 1, 1);

                    dt =dt.AddMilliseconds(long.Parse(match.Groups[1].Value));

                    dt = dt.ToLocalTime();

                    returndt.ToString("yyyy-MM-dd HH:mm:ss");

                });

            }

            return str;

        }

 

        /// <summary>

        /// json转换object动态类

        /// add yuangang by 2015-05-19

        /// </summary>

        /// <paramname="json"></param>

        /// <returns></returns>

        public static dynamicConvertJson(string json)

        {

            JavaScriptSerializer jss = newJavaScriptSerializer();

            jss.RegisterConverters(newJavaScriptConverter[] { new DynamicJsonConverter() });

            dynamic dy = jss.Deserialize(json,typeof(object)) as dynamic;

            return dy;

        }

 

        /// <summary>  

        /// DataReader转换为Json  

        /// </summary>  

        /// <paramname="dataReader">DataReader对象</param>  

        /// <returns>Json字符串</returns>  

        public static string ToJson(IDataReaderdataReader)

        {

            try

            {

                StringBuilder jsonString = newStringBuilder();

               jsonString.Append("[");

 

                while (dataReader.Read())

                {

                   jsonString.Append("{");

                    for (int i = 0; i <dataReader.FieldCount; i++)

                    {

                        Type type =dataReader.GetFieldType(i);

                        string strKey =dataReader.GetName(i);

                        string strValue =dataReader[i].ToString();

                       jsonString.Append("\"" + strKey + "\":");

                        strValue =StringFormat(strValue, type);

                        if (i <dataReader.FieldCount - 1)

                        {

                           jsonString.Append(strValue + ",");

                        }

                        else

                        {

                           jsonString.Append(strValue);

                        }

                    }

                   jsonString.Append("},");

                }

                if (!dataReader.IsClosed)

                {

                    dataReader.Close();

                }

               jsonString.Remove(jsonString.Length - 1, 1);

               jsonString.Append("]");

                if (jsonString.Length == 1)

                {

                    return "[]";

                }

                return jsonString.ToString();

            }

            catch (Exception ex)

            {

                throw ex;

            }

        }

 

        /// <summary>  

        /// DataSet转换为Json  

        /// add yuangang by 2015-05-19

        /// </summary>  

        /// <paramname="dataSet">DataSet对象</param>  

        /// <returns>Json字符串</returns>  

        public static string ToJson(DataSetdataSet)

        {

            string jsonString = "{";

            foreach (DataTable table indataSet.Tables)

            {

                jsonString +="\"" + table.TableName + "\":" + ToJson(table) +",";

            }

            jsonString =jsonString.TrimEnd(',');

            return jsonString + "}";

        }

        /// <summary> 

        /// DataTable转成Json  

        /// add yuangang by 2015-05-19

        /// </summary> 

        /// <paramname="jsonName"></param> 

        /// <paramname="dt"></param> 

        ///<returns></returns> 

        public static string ToJson(DataTabledt, string jsonName)

        {

            StringBuilder Json = newStringBuilder();

            if (string.IsNullOrEmpty(jsonName))

                jsonName = dt.TableName;

            Json.Append("{\"" +jsonName + "\":[");

            if (dt.Rows.Count > 0)

            {

                for (int i = 0; i <dt.Rows.Count; i++)

                {

                    Json.Append("{");

                    for (int j = 0; j <dt.Columns.Count; j++)

                    {

                        Type type =dt.Rows[i][j].GetType();

                       Json.Append("\"" + dt.Columns[j].ColumnName.ToString() +"\":" + StringFormat(dt.Rows[i][j] is DBNull ? string.Empty :dt.Rows[i][j].ToString(), type));

                        if (j <dt.Columns.Count - 1)

                        {

                           Json.Append(",");

                        }

                    }

                    Json.Append("}");

                    if (i < dt.Rows.Count -1)

                    {

                       Json.Append(",");

                    }

                }

            }

            Json.Append("]}");

            return Json.ToString();

        }

        /// <summary>  

        /// Datatable转换为Json  

        /// add yuangang by 2015-05-19

        /// </summary>  

        /// <paramname="table">Datatable对象</param>  

        /// <returns>Json字符串</returns>  

        public static string ToJson(DataTabledt)

        {

            StringBuilder jsonString = newStringBuilder();

            jsonString.Append("[");

            DataRowCollection drc = dt.Rows;

            for (int i = 0; i < drc.Count;i++)

            {

               jsonString.Append("{");

                for (int j = 0; j <dt.Columns.Count; j++)

                {

                    string strKey =dt.Columns[j].ColumnName;

                    string strValue =drc[i][j].ToString();

                    Type type =dt.Columns[j].DataType;

                   jsonString.Append("\"" + strKey + "\":");

                    strValue =StringFormat(strValue, type);

                    if (j < dt.Columns.Count- 1)

                    {

                       jsonString.Append(strValue + ",");

                    }

                    else

                    {

                       jsonString.Append(strValue);

                    }

                }

               jsonString.Append("},");

            }

            jsonString.Remove(jsonString.Length- 1, 1);

            jsonString.Append("]");

            if (jsonString.Length == 1)

            {

                return "[]";

            }

            return jsonString.ToString();

        } 

        /// <summary> 

        ///格式化字符型、日期型、布尔型 

        /// add yuangang by 2015-05-19

        /// </summary> 

        /// <paramname="str"></param> 

        /// <paramname="type"></param> 

        ///<returns></returns> 

        private static stringStringFormat(string str, Type type)

        {

            if (type != typeof(string)&& string.IsNullOrEmpty(str))

            {

                str = "\"" + str+ "\"";

            }

            else if (type == typeof(string))

            {

                str = String2Json(str);

                str = "\"" + str+ "\"";

            }

            else if (type == typeof(DateTime))

            {

                str = "\"" + str+ "\"";

            }

            else if (type == typeof(bool))

            {

                str = str.ToLower();

            }

            else if (type == typeof(byte[]))

            {

                str = "\"" + str+ "\"";

            }

            else if (type == typeof(Guid))

            {

                str = "\"" + str+ "\"";

            }

            return str;

        }

        /// <summary> 

        ///过滤特殊字符 

        /// add yuangang by 2015-05-19

        /// </summary> 

        /// <paramname="s"></param> 

        ///<returns></returns> 

        public static string String2Json(Strings)

        {

            StringBuilder sb = newStringBuilder();

            for (int i = 0; i < s.Length;i++)

            {

                char c = s.ToCharArray()[i];

                switch (c)

                {

                    case '\"':

                       sb.Append("\\\""); break;

                    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;

                    case '\v':

                       sb.Append("\\v"); break;

                    case '\0':

                       sb.Append("\\0"); break;

                    default:

                        sb.Append(c); break;

                }

            }

            return sb.ToString();

        }

 

        public static stringGetDataGridJsonByDataSet(DataSet ds, string totalProperty, string root)

        {

            returnGetDataGridJsonByDataTable(ds.Tables[0], totalProperty, root);

        }

        public static stringGetDataGridJsonByDataTable(DataTable dt, string totalProperty, string root)

        {

            StringBuilder jsonBuilder = newStringBuilder();

           jsonBuilder.Append("({\"" + totalProperty +"\":\"" + dt.Rows.Count + "\",");

           jsonBuilder.Append("\"");

            jsonBuilder.Append(root);

           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();

        }

 

        public static stringGetTreeJsonByDataSet(DataSet ds)

        {

            returnGetTreeJsonByDataTable(ds.Tables[0]);

        }

        public static stringGetTreeJsonByDataTable(DataTable dataTable)

        {

            DataTable dt =FormatDataTableForTree(dataTable);

            StringBuilder jsonBuilder = newStringBuilder();

            jsonBuilder.Append("[");

            for (int i = 0; i <dt.Rows.Count; i++)

            {

               jsonBuilder.Append("{");

                for (int j = 0; j <dt.Columns.Count; j++)

                {

                   jsonBuilder.Append("\'");

 

                    if(dt.Columns[j].ColumnName == "leaf")

                    {

                        string leafValue =dt.Rows[i][j].ToString();

 

                        if(!string.IsNullOrEmpty(leafValue))

                        {

                           jsonBuilder.Append(dt.Columns[j].ColumnName);

                           jsonBuilder.Append("\':\'");

                           jsonBuilder.Append(dt.Rows[i][j].ToString());

                           jsonBuilder.Append("\',");

                        }

                        else

                        {

                           jsonBuilder.Remove(jsonBuilder.Length - 1, 1);

                        }

                    }

                    else if(dt.Columns[j].ColumnName == "customUrl")

                    {

                       jsonBuilder.Remove(jsonBuilder.Length - 1, 1);

                       jsonBuilder.Append(dt.Columns[j].ColumnName);

                       jsonBuilder.Append(":\'");

                       jsonBuilder.Append(dt.Rows[i][j].ToString());

                       jsonBuilder.Append("\',");

                    }

                    else

                    {

                       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("]");

            return jsonBuilder.ToString();

        }

        private static DataTableFormatDataTableForTree(DataTable dt)

        {

            DataTable dtTree = new DataTable();

            dtTree.Columns.Add("id",typeof(string));

           dtTree.Columns.Add("text", typeof(string));

           dtTree.Columns.Add("leaf", typeof(string));

            dtTree.Columns.Add("cls",typeof(string));

           dtTree.Columns.Add("customUrl", typeof(string));

            dtTree.AcceptChanges();

 

            for (int i = 0; i <dt.Rows.Count; i++)

            {

                DataRow drTree =dtTree.NewRow();

                drTree["id"] =dt.Rows[i]["id"].ToString();

                drTree["text"] =dt.Rows[i]["text"].ToString();

                if(dt.Rows[i]["leaf"].ToString() == "Y")

                {

                    drTree["leaf"] ="true";

                    drTree["cls"] ="file";

                }

                else

                {

                    drTree["cls"] ="folder";

                }

                drTree["customUrl"] =dt.Rows[i]["customUrl"].ToString();

                dtTree.Rows.Add(drTree);

            }

            return dtTree;

        }

 

    }

    /// <summary>

    ///动态JSON解析

    /// add yuangang by 2015-05-19

    /// </summary>

    public class DynamicJsonObject :System.Dynamic.DynamicObject

    {

        private IDictionary<string,object> Dictionary { get; set; }

 

        publicDynamicJsonObject(IDictionary<string, object> dictionary)

        {

            this.Dictionary = dictionary;

        }

 

        public override boolTryGetMember(System.Dynamic.GetMemberBinder binder, out object result)

        {

            result =this.Dictionary[binder.Name];

 

            if (result isIDictionary<string, object>)

            {

                result = newDynamicJsonObject(result as IDictionary<string, object>);

            }

            else if (result is ArrayList&& (result as ArrayList) is IDictionary<string, object>)

            {

                result = newList<DynamicJsonObject>((result as ArrayList).ToArray().Select(x =>new DynamicJsonObject(x as IDictionary<string, object>)));

            }

            else if (result is ArrayList)

            {

                result = newList<object>((result as ArrayList).ToArray());

            }

 

            returnthis.Dictionary.ContainsKey(binder.Name);

        }

    }

    /// <summary>

    ///动态JSON转换

    /// add yuangang by 2015-05-19

    /// </summary>

    public class DynamicJsonConverter :JavaScriptConverter

    {

        public override objectDeserialize(IDictionary<string, object> dictionary, Type type,JavaScriptSerializer serializer)

        {

            if (dictionary == null)

                throw newArgumentNullException("dictionary");

 

            if (type == typeof(object))

            {

                return newDynamicJsonObject(dictionary);

            }

 

            return null;

        }

 

        public override IDictionary<string,object> Serialize(object obj, JavaScriptSerializer serializer)

        {

            throw newNotImplementedException();

        }

 

        public override IEnumerable<Type>SupportedTypes

        {

            get { return newSystem.Collections.ObjectModel.ReadOnlyCollection<Type>(newList<Type>(new Type[] { typeof(object) })); }

        }

    }

}

二、JsonHelper：json的辅助类

 

来自<http://www.cnblogs.com/yuangang/p/5468777.html>

usingSystem.Collections.Generic;

using System.Text;

usingNewtonsoft.Json;

usingSystem.Runtime.Serialization.Json;

using System.IO;

 

namespace Common

{

 

    /// <summary>

    ///提供了一个关于json的辅助类

    /// </summary>

    public class JsonHelper

    {

        #region Method

        /// <summary>

        ///类对像转换成json格式

        /// </summary>

        /// <returns></returns>

        public static string ToJson(object t)

        {

          return JsonConvert.SerializeObject(t,Newtonsoft.Json.Formatting.Indented, new JsonSerializerSettings {NullValueHandling = NullValueHandling.Include });

        }

        /// <summary>

        ///类对像转换成json格式

        /// </summary>

        /// <paramname="t"></param>

        /// <paramname="HasNullIgnore">是否忽略NULL值</param>

        /// <returns></returns>

        public static string ToJson(object t,bool HasNullIgnore)

        {

            if (HasNullIgnore)

                returnJsonConvert.SerializeObject(t, Newtonsoft.Json.Formatting.Indented, newJsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore });

            else

                return ToJson(t);

        }

        /// <summary>

        /// json格式转换

        /// </summary>

        /// <typeparamname="T"></typeparam>

        /// <paramname="strJson"></param>

        /// <returns></returns>

        public static TFromJson<T>(string strJson) where T : class

        {

            if (!strJson.IsNullOrEmpty())

                returnJsonConvert.DeserializeObject<T>(strJson);

            return null;

        }

        /// <summary>

        ///功能描述：将List转换为Json

        /// </summary>

        /// <paramname="a"></param>

        /// <returns></returns>

        public static stringListToJson(IList<object> a)

        {

 

            DataContractJsonSerializer json =new DataContractJsonSerializer(a.GetType());

            string szJson = "";

            //序列化

            using (MemoryStream stream = newMemoryStream())

            {

                json.WriteObject(stream, a);

                szJson =Encoding.UTF8.GetString(stream.ToArray());

            }

            return szJson;

        }

        #endregion

 

        #region Property

        /// <summary>

        ///数据状态

        /// </summary>

        public string Status { get; set; }

        /// <summary>

        ///提示信息

        /// </summary>

        public string Msg { get; set; }

        /// <summary>

        ///回传URL

        /// </summary>

        public string ReUrl { get; set; }

        /// <summary>

        ///数据包

        /// </summary>

        public object Data { get; set; }

        #endregion

 

    }

}

三、JsonSplit：判断字符串是否为Json

 

来自<http://www.cnblogs.com/yuangang/p/5468777.html>

using System;

usingSystem.Collections.Generic;

using System.Linq;

using System.Web;

 

namespace Common

{

    /// <summary>

    ///判断字符串是否为JSON

    /// </summary>

    public class JsonSplit

    {

        private static bool IsJsonStart(refstring json)

        {

            if (!string.IsNullOrEmpty(json))

            {

                json = json.Trim('\r', '\n', '');

                if (json.Length > 1)

                {

                    char s = json[0];

                    char e = json[json.Length -1];

                    return (s == '{' &&e == '}') || (s == '[' && e == ']');

                }

            }

            return false;

        }

        public static bool IsJson(string json)

        {

            int errIndex;

            return IsJson(json, out errIndex);

        }

        public static bool IsJson(string json,out int errIndex)

        {

            errIndex = 0;

            if (IsJsonStart(ref json))

            {

                CharState cs = new CharState();

                char c;

                for (int i = 0; i <json.Length; i++)

                {

                    c = json[i];

                    if (SetCharState(c, ref cs)&& cs.childrenStart)//设置关键符号状态。

                    {

                        string item =json.Substring(i);

                        int err;

                        int length =GetValueLength(item, true, out err);

                        cs.childrenStart =false;

                        if (err > 0)

                        {

                            errIndex = i + err;

                            return false;

                        }

                        i = i + length - 1;

                    }

                    if (cs.isError)

                    {

                        errIndex = i;

                        return false;

                    }

                }

 

                return !cs.arrayStart&& !cs.jsonStart;

            }

            return false;

        }

 

        /// <summary>

        ///获取值的长度（当Json值嵌套以"{"或"["开头时）

        /// </summary>

        private static intGetValueLength(string json, bool breakOnErr, out int errIndex)

        {

            errIndex = 0;

            int len = 0;

            if (!string.IsNullOrEmpty(json))

            {

                CharState cs = new CharState();

                char c;

                for (int i = 0; i <json.Length; i++)

                {

                    c = json[i];

                    if (!SetCharState(c, refcs))//设置关键符号状态。

                    {

                        if (!cs.jsonStart&& !cs.arrayStart)//json结束，又不是数组，则退出。

                        {

                            break;

                        }

                    }

                    else if(cs.childrenStart)//正常字符，值状态下。

                    {

                        int length =GetValueLength(json.Substring(i), breakOnErr, out errIndex);//递归子值，返回一个长度。。。

                        cs.childrenStart =false;

                        cs.valueStart = 0;

                        //cs.state = 0;

                        i = i + length - 1;

                    }

                    if (breakOnErr &&cs.isError)

                    {

                        errIndex = i;

                        return i;

                    }

                    if (!cs.jsonStart&& !cs.arrayStart)//记录当前结束位置。

                    {

                        len = i + 1;//长度比索引+1

                        break;

                    }

                }

            }

            return len;

        }

        /// <summary>

        ///字符状态

        /// </summary>

        private class CharState

        {

            internal bool jsonStart = false;//以"{"开始了...

            internal bool setDicValue =false;//可以设置字典值了。

            internal bool escapeChar = false;//以"\"转义符号开始了

            /// <summary>

            ///数组开始【仅第一开头才算】，值嵌套的以【childrenStart】来标识。

            /// </summary>

            internal bool arrayStart = false;//以"["符号开始了

            internal bool childrenStart =false;//子级嵌套开始了。

            /// <summary>

            ///【0初始状态，或 遇到“,”逗号】；【1遇到“：”冒号】

            /// </summary>

            internal int state = 0;

 

            /// <summary>

            ///【-1取值结束】【0未开始】【1无引号开始】【2单引号开始】【3双引号开始】

            /// </summary>

            internal int keyStart = 0;

            /// <summary>

            ///【-1取值结束】【0未开始】【1无引号开始】【2单引号开始】【3双引号开始】

            /// </summary>

            internal int valueStart = 0;

            internal bool isError = false;//是否语法错误。

 

            internal void CheckIsError(charc)//只当成一级处理（因为GetLength会递归到每一个子项处理）

            {

                if (keyStart > 1 ||valueStart > 1)

                {

                    return;

                }

                //示例["aa",{"bbbb":123,"fff","ddd"}]

                switch (c)

                {

                    case '{'://[{"[{A}]":[{"[{B}]":3,"m":"C"}]}]

                        isError = jsonStart&& state == 0;//重复开始错误同时不是值处理。

                        break;

                    case '}':

                        isError = !jsonStart ||(keyStart != 0 && state == 0);//重复结束错误或者 提前结束{"aa"}。正常的有{}

                        break;

                    case '[':

                        isError = arrayStart&& state == 0;//重复开始错误

                        break;

                    case ']':

                        isError = !arrayStart|| jsonStart;//重复开始错误 或者 Json未结束

                        break;

                    case '"':

                    case '\'':

                        isError = !(jsonStart|| arrayStart); //json或数组开始。

                        if (!isError)

                        {

                            //重复开始[""",{"" "}]

                            isError = (state ==0 && keyStart == -1) || (state == 1 && valueStart == -1);

                        }

                        if (!isError &&arrayStart && !jsonStart && c == '\'')//['aa',{}]

                        {

                            isError = true;

                        }

                        break;

                    case ':':

                        isError = !jsonStart ||state == 1;//重复出现。

                        break;

                    case ',':

                        isError = !(jsonStart|| arrayStart); //json或数组开始。

                        if (!isError)

                        {

                            if (jsonStart)

                            {

                                isError = state== 0 || (state == 1 && valueStart > 1);//重复出现。

                            }

                            else if(arrayStart)//["aa,] [,]  [{},{}]

                            {

                                isError =keyStart == 0 && !setDicValue;

                            }

                        }

                        break;

                    case ' ':

                    case '\r':

                    case '\n'://["a",\r\n{} ]

                    case '\0':

                    case '\t':

                        break;

                    default: //值开头。。

                        isError = (!jsonStart&& !arrayStart) || (state == 0 && keyStart == -1) ||(valueStart == -1 && state == 1);//

                        break;

                }

                //if (isError)

                //{

 

                //}

            }

        }

        /// <summary>

        ///设置字符状态(返回true则为关键词，返回false则当为普通字符处理）

        /// </summary>

        private static bool SetCharState(charc, ref CharState cs)

        {

            cs.CheckIsError(c);

            switch (c)

            {

                case '{'://[{"[{A}]":[{"[{B}]":3,"m":"C"}]}]

                    #region大括号

                    if (cs.keyStart <= 0&& cs.valueStart <= 0)

                    {

                        cs.keyStart = 0;

                        cs.valueStart = 0;

                        if (cs.jsonStart&& cs.state == 1)

                        {

                            cs.childrenStart =true;

                        }

                        else

                        {

                            cs.state = 0;

                        }

                        cs.jsonStart = true;//开始。

                        return true;

                    }

                    #endregion

                    break;

                case '}':

                    #region大括号结束

                    if (cs.keyStart <= 0&& cs.valueStart < 2 && cs.jsonStart)

                    {

                        cs.jsonStart = false;//正常结束。

                        cs.state = 0;

                        cs.keyStart = 0;

                        cs.valueStart = 0;

                        cs.setDicValue = true;

                        return true;

                    }

                    // cs.isError =!cs.jsonStart && cs.state == 0;

                    #endregion

                    break;

                case '[':

                    #region中括号开始

                    if (!cs.jsonStart)

                    {

                        cs.arrayStart = true;

                        return true;

                    }

                    else if (cs.jsonStart&& cs.state == 1)

                    {

                        cs.childrenStart =true;

                        return true;

                    }

                    #endregion

                    break;

                case ']':

                    #region中括号结束

                    if (cs.arrayStart&& !cs.jsonStart && cs.keyStart <= 2 &&cs.valueStart <= 0)//[{},333]//这样结束。

                    {

                        cs.keyStart = 0;

                        cs.valueStart = 0;

                        cs.arrayStart = false;

                        return true;

                    }

                    #endregion

                    break;

                case '"':

                case '\'':

                    #region引号

                    if (cs.jsonStart ||cs.arrayStart)

                    {

                        if (cs.state == 0)//key阶段,有可能是数组["aa",{}]

                        {

                            if (cs.keyStart<= 0)

                            {

                                cs.keyStart =(c == '"' ? 3 : 2);

                                return true;

                            }

                            else if((cs.keyStart == 2 && c == '\'') || (cs.keyStart == 3 && c =='"'))

                            {

                                if(!cs.escapeChar)

                                {

                                    cs.keyStart= -1;

                                    returntrue;

                                }

                                else

                                {

                                   cs.escapeChar = false;

                                }

                            }

                        }

                        else if (cs.state == 1&& cs.jsonStart)//值阶段必须是Json开始了。

                        {

                            if (cs.valueStart<= 0)

                            {

                                cs.valueStart =(c == '"' ? 3 : 2);

                                return true;

                            }

                            else if((cs.valueStart == 2 && c == '\'') || (cs.valueStart == 3 && c== '"'))

                            {

                                if(!cs.escapeChar)

                                {

                                   cs.valueStart = -1;

                                    returntrue;

                                }

                                else

                                {

                                   cs.escapeChar = false;

                                }

                            }

 

                        }

                    }

                    #endregion

                    break;

                case ':':

                    #region冒号

                    if (cs.jsonStart &&cs.keyStart < 2 && cs.valueStart < 2 && cs.state == 0)

                    {

                        if (cs.keyStart == 1)

                        {

                            cs.keyStart = -1;

                        }

                        cs.state = 1;

                        return true;

                    }

                    // cs.isError =!cs.jsonStart || (cs.keyStart < 2 && cs.valueStart < 2 &&cs.state == 1);

                    #endregion

                    break;

                case ',':

                    #region逗号//["aa",{aa:12,}]

 

                    if (cs.jsonStart)

                    {

                        if (cs.keyStart < 2&& cs.valueStart < 2 && cs.state == 1)

                        {

                            cs.state = 0;

                            cs.keyStart = 0;

                            cs.valueStart = 0;

                            //if (cs.valueStart== 1)

                            //{

                            //    cs.valueStart = 0;

                            //}

                            cs.setDicValue =true;

                            return true;

                        }

                    }

                    else if (cs.arrayStart&& cs.keyStart <= 2)

                    {

                        cs.keyStart = 0;

                        //if (cs.keyStart == 1)

                        //{

                        //    cs.keyStart = -1;

                        //}

                        return true;

                    }

                    #endregion

                    break;

                case ' ':

                case '\r':

                case '\n'://["a",\r\n{} ]

                case '\0':

                case '\t':

                    if (cs.keyStart <= 0&& cs.valueStart <= 0) //cs.jsonStart &&

                    {

                        return true;//跳过空格。

                    }

                    break;

                default: //值开头。。

                    if (c == '\\') //转义符号

                    {

                        if (cs.escapeChar)

                        {

                            cs.escapeChar =false;

                        }

                        else

                        {

                            cs.escapeChar =true;

                            return true;

                        }

                    }

                    else

                    {

                        cs.escapeChar = false;

                    }

                    if (cs.jsonStart ||cs.arrayStart) // Json或数组开始了。

                    {

                        if (cs.keyStart <= 0&& cs.state == 0)

                        {

                            cs.keyStart = 1;//无引号的

                        }

                        else if (cs.valueStart<= 0 && cs.state == 1 && cs.jsonStart)//只有Json开始才有值。

                        {

                            cs.valueStart =1;//无引号的

                        }

                    }

                    break;

            }

            return false;

        }

    }

}

四、AjaxResult：前台Ajax请求的统一返回结果类

 

来自<http://www.cnblogs.com/yuangang/p/5468777.html>

usingSystem.Web.Script.Serialization;

namespace Common

{

    /// <summary>

    ///前台Ajax请求的统一返回结果类

    /// </summary>

    public class AjaxResult

    {

        private AjaxResult()

        {

        }

 

        private bool iserror = false;

 

        /// <summary>

        ///是否产生错误

        /// </summary>

        public bool IsError { get { returniserror; } }

 

        /// <summary>

        ///错误信息，或者成功信息

        /// </summary>

        public string Message { get; set; }

 

        /// <summary>

        ///成功可能时返回的数据

        /// </summary>

        public object Data { get; set; }

 

        #region Error

        public static AjaxResult Error()

        {

            return new AjaxResult()

            {

                iserror = true

            };

        }

        public static AjaxResult Error(stringmessage)

        {

            return new AjaxResult()

            {

                iserror = true,

                Message = message

            };

        }

        #endregion

 

        #region Success

        public static AjaxResult Success()

        {

            return new AjaxResult()

            {

                iserror = false

            };

        }

        public static AjaxResult Success(stringmessage)

        {

            return new AjaxResult()

            {

                iserror = false,

                Message = message

            };

        }

        public static AjaxResult Success(objectdata)

        {

            return new AjaxResult()

            {

                iserror = false,

                Data = data

            };

        }

        public static AjaxResult Success(objectdata, string message)

        {

            return new AjaxResult()

            {

                iserror = false,

                Data = data,

                Message = message

            };

        }

        #endregion

 

        /// <summary>

        ///序列化

        /// </summary>

        /// <returns></returns>

        public override string ToString()

        {

            return newJavaScriptSerializer().Serialize(this);

        }

    }

}