using System;
using System.Collections.Generic;
using System.Text;
using System.Data;
using System.Linq;
using System.Web.Script.Serialization;
using System.Collections;

namespace Common
{
  public class JsonConverter
  {
    
    /// <summary>
    /// 自定义查询对象转换动态类
    /// add yuangang by 2015-05-19
    /// </summary>
    /// <param name=\"obj\"></param>
    /// <returns></returns>
    public static dynamic JsonClass(object obj) 
    {
      return ConvertJson(Serialize(obj, true));
    }

    /// <summary>
    /// object动态类转换json包
    /// add yuangang by 2015-05-19
    /// </summary>
    /// <param name=\"obj\">对象</param>
    /// <param name=\"DateConvert\">时间戳是否转换成日期类型</param>
    /// <returns></returns>
    public static string Serialize(object obj, bool DateConvert = false)
    {
      JavaScriptSerializer jss = new JavaScriptSerializer();
      var str = jss.Serialize(obj);
      if (DateConvert)
      {
        str = System.Text.RegularExpressions.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>
    /// json转换object动态类
    /// add yuangang by 2015-05-19
    /// </summary>
    /// <param name=\"json\"></param>
    /// <returns></returns>
    public static dynamic ConvertJson(string json)
    {
      JavaScriptSerializer jss = new JavaScriptSerializer();
      jss.RegisterConverters(new JavaScriptConverter[] { new DynamicJsonConverter() });
      dynamic dy = jss.Deserialize(json, typeof(object)) as dynamic;
      return dy;
    }

    /// <summary>  
    /// DataReader转换为Json  
    /// </summary>  
    /// <param name=\"dataReader\">DataReader对象</param>  
    /// <returns>Json字符串</returns>  
    public static string ToJson(IDataReader dataReader)
    {
      try
      {
        StringBuilder jsonString = new StringBuilder();
        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>  
    /// <param name=\"dataSet\">DataSet对象</param>  
    /// <returns>Json字符串</returns>  
    public static string ToJson(DataSet dataSet)
    {
      string jsonString = \"{\";
      foreach (DataTable table in dataSet.Tables)
      {
        jsonString += \"\\\"\" + table.TableName + \"\\\":\" + ToJson(table) + \",\";
      }
      jsonString = jsonString.TrimEnd(\',\');
      return jsonString + \"}\";
    }
    /// <summary> 
    /// DataTable转成Json  
    /// add yuangang by 2015-05-19
    /// </summary> 
    /// <param name=\"jsonName\"></param> 
    /// <param name=\"dt\"></param> 
    /// <returns></returns> 
    public static string ToJson(DataTable dt, string jsonName)
    {
      StringBuilder Json = new StringBuilder();
      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>  
    /// <param name=\"table\">Datatable对象</param>  
    /// <returns>Json字符串</returns>  
    public static string ToJson(DataTable dt)
    {
      StringBuilder jsonString = new StringBuilder();
      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> 
    /// <param name=\"str\"></param> 
    /// <param name=\"type\"></param> 
    /// <returns></returns> 
    private static string StringFormat(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> 
    /// <param name=\"s\"></param> 
    /// <returns></returns> 
    public static string String2Json(String s)
    {
      StringBuilder sb = new StringBuilder();
      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 string GetDataGridJsonByDataSet(DataSet ds, string totalProperty, string root)
    {
      return GetDataGridJsonByDataTable(ds.Tables[0], totalProperty, root);
    }
    public static string GetDataGridJsonByDataTable(DataTable dt, string totalProperty, string root)
    {
      StringBuilder jsonBuilder = new StringBuilder();
      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 string GetTreeJsonByDataSet(DataSet ds)
    {
      return GetTreeJsonByDataTable(ds.Tables[0]);
    }
    public static string GetTreeJsonByDataTable(DataTable dataTable)
    {
      DataTable dt = FormatDataTableForTree(dataTable);
      StringBuilder jsonBuilder = new StringBuilder();
      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 DataTable FormatDataTableForTree(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; }

    public DynamicJsonObject(IDictionary<string, object> dictionary)
    {
      this.Dictionary = dictionary;
    }

    public override bool TryGetMember(System.Dynamic.GetMemberBinder binder, out object result)
    {
      result = this.Dictionary[binder.Name];

      if (result is IDictionary<string, object>)
      {
        result = new DynamicJsonObject(result as IDictionary<string, object>);
      }
      else if (result is ArrayList && (result as ArrayList) is IDictionary<string, object>)
      {
        result = new List<DynamicJsonObject>((result as ArrayList).ToArray().Select(x => new DynamicJsonObject(x as IDictionary<string, object>)));
      }
      else if (result is ArrayList)
      {
        result = new List<object>((result as ArrayList).ToArray());
      }

      return this.Dictionary.ContainsKey(binder.Name);
    }
  }
  /// <summary>
  /// 动态JSON转换
  /// add yuangang by 2015-05-19
  /// </summary>
  public class DynamicJsonConverter : JavaScriptConverter
  {
    public override object Deserialize(IDictionary<string, object> dictionary, Type type, JavaScriptSerializer serializer)
    {
      if (dictionary == null)
        throw new ArgumentNullException(\"dictionary\");

      if (type == typeof(object))
      {
        return new DynamicJsonObject(dictionary);
      }

      return null;
    }

    public override IDictionary<string, object> Serialize(object obj, JavaScriptSerializer serializer)
    {
      throw new NotImplementedException();
    }

    public override IEnumerable<Type> SupportedTypes
    {
      get { return new System.Collections.ObjectModel.ReadOnlyCollection<Type>(new List<Type>(new Type[] { typeof(object) })); }
    }
  }
}

using System.Collections.Generic;
using System.Text;
using Newtonsoft.Json;
using System.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>
    /// <param name=\"t\"></param>
    /// <param name=\"HasNullIgnore\">是否忽略NULL值</param>
    /// <returns></returns>
    public static string ToJson(object t, bool HasNullIgnore)
    {
      if (HasNullIgnore)
        return JsonConvert.SerializeObject(t, Newtonsoft.Json.Formatting.Indented, new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore });
      else
        return ToJson(t);
    }
    /// <summary>
    /// json格式转换
    /// </summary>
    /// <typeparam name=\"T\"></typeparam>
    /// <param name=\"strJson\"></param>
    /// <returns></returns>
    public static T FromJson<T>(string strJson) where T : class
    {
      if (!strJson.IsNullOrEmpty())
        return JsonConvert.DeserializeObject<T>(strJson);
      return null;
    }
    /// <summary>
    /// 功能描述：将List转换为Json
    /// </summary>
    /// <param name=\"a\"></param>
    /// <returns></returns>
    public static string ListToJson(IList<object> a)
    {

      DataContractJsonSerializer json = new DataContractJsonSerializer(a.GetType());
      string szJson = \"\";
      //序列化
      using (MemoryStream stream = new MemoryStream())
      {
        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

  }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

namespace Common
{
  /// <summary>
  /// 判断字符串是否为JSON
  /// </summary>
  public class JsonSplit
  {
    private static bool IsJsonStart(ref string 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 int GetValueLength(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, ref cs))//设置关键符号状态。
          {
            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(char c)//只当成一级处理（因为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(char c, 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;
                  return true;
                }
                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;
                  return true;
                }
                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;
    }
  }
}

using System.Web.Script.Serialization;
namespace Common
{
  /// <summary>
  /// 前台Ajax请求的统一返回结果类
  /// </summary>
  public class AjaxResult
  {
    private AjaxResult()
    {
    }

    private bool iserror = false;

    /// <summary>
    /// 是否产生错误
    /// </summary>
    public bool IsError { get { return iserror; } }

    /// <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(string message)
    {
      return new AjaxResult()
      {
        iserror = true,
        Message = message
      };
    }
    #endregion

    #region Success
    public static AjaxResult Success()
    {
      return new AjaxResult()
      {
        iserror = false
      };
    }
    public static AjaxResult Success(string message)
    {
      return new AjaxResult()
      {
        iserror = false,
        Message = message
      };
    }
    public static AjaxResult Success(object data)
    {
      return new AjaxResult()
      {
        iserror = false,
        Data = data
      };
    }
    public static AjaxResult Success(object data, string message)
    {
      return new AjaxResult()
      {
        iserror = false,
        Data = data,
        Message = message
      };
    }
    #endregion

    /// <summary>
    /// 序列化
    /// </summary>
    /// <returns></returns>
    public override string ToString()
    {
      return new JavaScriptSerializer().Serialize(this);
    }
  }
}