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></retu
4000
rns>
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
14de1
<= 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);
}
}
}