ChangShaSanYi/ChuanSuoCheKu.git

¶Ô±ÈÐÂÎÄ¼þ
			@@ -0,0 +1,983 @@
			ï»¿using NetTaste;
			using Newtonsoft.Json;
			using System;
			using System.Collections.Generic;
			using System.Data;
			using System.Linq;
			using System.Reflection;
			using System.Text;
			using System.Text.RegularExpressions;
			using System.Threading.Tasks;
			using System.Web;
			using WIDESEA_Core.Const;
			using WIDESEA_Core.Enums;

			namespace WIDESEA_Core.Helper
			{
			public static class UtilConvert
			{
			private static DateTime dateStart = new DateTime(1970, 1, 1, 8, 0, 0);

			private static long longTime = 621355968000000000;

			private static int samllTime = 10000000;
			/// <summary>
			/// æ¶é´æ³è½¬æ¢ææ¥æ
			/// </summary>
			/// <param name="timeStamp"></param>
			/// <returns></returns>
			public static DateTime GetTimeSpmpToDate(this object timeStamp)
			{
			if (timeStamp == null) return dateStart;
			DateTime dateTime = new DateTime(longTime + Convert.ToInt64(timeStamp) * samllTime, DateTimeKind.Utc).ToLocalTime();
			return dateTime;
			}

			public static string Serialize(this object obj, JsonSerializerSettings formatDate = null)
			{
			if (obj == null) return null;
			formatDate = formatDate ?? new JsonSerializerSettings
			{
			DateFormatString = "yyyy-MM-dd HH:mm:ss"
			};
			return JsonConvert.SerializeObject(obj, formatDate);
			}

			public static T DeserializeObject<T>(this string json)
			{
			if (string.IsNullOrEmpty(json))
			{
			return default(T);
			}
			if (json == "{}")
			{
			json = "[]";
			}
			return JsonConvert.DeserializeObject<T>(json);
			}

			public static string FirstLetterToLower(this string thisValue)
			{
			if (string.IsNullOrEmpty(thisValue)) return string.Empty;
			string result = thisValue.Substring(0, 1).ToLower() + thisValue.Substring(1, thisValue.Length - 1);
			return result;
			}

			public static string FirstLetterToUpper(this string thisValue)
			{
			if (string.IsNullOrEmpty(thisValue)) return string.Empty;
			string result = thisValue.Substring(0, 1).ToUpper() + thisValue.Substring(1, thisValue.Length - 1);
			return result;
			}

			/// <summary>
			///
			/// </summary>
			/// <param name="thisValue"></param>
			/// <returns></returns>
			public static int ObjToInt(this object thisValue)
			{
			int reval = 0;
			if (thisValue == null) return 0;
			if (thisValue is Enum && thisValue != DBNull.Value && Enum.TryParse(thisValue.GetType(), thisValue.ToString(), out var val))
			{
			return Convert.ToInt32(val.ChangeType(typeof(int)));
			}
			if (thisValue != DBNull.Value && int.TryParse(thisValue.ToString(), out reval))
			{
			return reval;
			}

			return reval;
			}

			/// <summary>
			///
			/// </summary>
			/// <param name="thisValue"></param>
			/// <returns></returns>
			public static int DoubleToInt(this double thisValue)
			{
			int reval = 0;

			return Convert.ToInt32(thisValue);
			}

			/// <summary>
			///
			/// </summary>
			/// <param name="thisValue"></param>
			/// <param name="errorValue"></param>
			/// <returns></returns>
			public static int ObjToInt(this object thisValue, int errorValue)
			{
			int reval = 0;
			if (thisValue != null && thisValue != DBNull.Value && int.TryParse(thisValue.ToString(), out reval))
			{
			return reval;
			}

			return errorValue;
			}

			public static long ObjToLong(this object thisValue)
			{
			long reval = 0;
			if (thisValue == null) return 0;
			if (thisValue != DBNull.Value && long.TryParse(thisValue.ToString(), out reval))
			{
			return reval;
			}

			return reval;
			}

			/// <summary>
			///
			/// </summary>
			/// <param name="thisValue"></param>
			/// <returns></returns>
			public static double ObjToMoney(this object thisValue)
			{
			double reval = 0;
			if (thisValue != null && thisValue != DBNull.Value && double.TryParse(thisValue.ToString(), out reval))
			{
			return reval;
			}

			return 0;
			}

			/// <summary>
			///
			/// </summary>
			/// <param name="thisValue"></param>
			/// <param name="errorValue"></param>
			/// <returns></returns>
			public static double ObjToMoney(this object thisValue, double errorValue)
			{
			double reval = 0;
			if (thisValue != null && thisValue != DBNull.Value && double.TryParse(thisValue.ToString(), out reval))
			{
			return reval;
			}

			return errorValue;
			}

			/// <summary>
			///
			/// </summary>
			/// <param name="thisValue"></param>
			/// <returns></returns>
			public static string ObjToString(this object thisValue)
			{
			if (thisValue != null) return thisValue.ToString().Trim();
			return "";
			}

			/// <summary>
			///
			/// </summary>
			/// <param name="thisValue"></param>
			/// <returns></returns>
			public static bool IsNotEmptyOrNull(this object thisValue)
			{
			return ObjToString(thisValue) != "" && ObjToString(thisValue) != "undefined" && ObjToString(thisValue) != "null";
			}

			/// <summary>
			///
			/// </summary>
			/// <param name="thisValue"></param>
			/// <param name="errorValue"></param>
			/// <returns></returns>
			public static string ObjToString(this object thisValue, string errorValue)
			{
			if (thisValue != null) return thisValue.ToString().Trim();
			return errorValue;
			}

			public static bool IsNullOrEmpty(this object thisValue) => thisValue == null \|\| thisValue == DBNull.Value \|\| string.IsNullOrWhiteSpace(thisValue.ToString());

			/// <summary>
			///
			/// </summary>
			/// <param name="thisValue"></param>
			/// <returns></returns>
			public static Decimal ObjToDecimal(this object thisValue)
			{
			Decimal reval = 0;
			if (thisValue != null && thisValue != DBNull.Value && decimal.TryParse(thisValue.ToString(), out reval))
			{
			return reval;
			}

			return 0;
			}

			/// <summary>
			///
			/// </summary>
			/// <param name="thisValue"></param>
			/// <param name="errorValue"></param>
			/// <returns></returns>
			public static Decimal ObjToDecimal(this object thisValue, decimal errorValue)
			{
			Decimal reval = 0;
			if (thisValue != null && thisValue != DBNull.Value && decimal.TryParse(thisValue.ToString(), out reval))
			{
			return reval;
			}

			return errorValue;
			}

			/// <summary>
			///
			/// </summary>
			/// <param name="thisValue"></param>
			/// <returns></returns>
			public static DateTime ObjToDate(this object thisValue)
			{
			DateTime reval = DateTime.MinValue;
			if (thisValue != null && thisValue != DBNull.Value && DateTime.TryParse(thisValue.ToString(), out reval))
			{
			reval = Convert.ToDateTime(thisValue);
			}

			return reval;
			}

			/// <summary>
			///
			/// </summary>
			/// <param name="thisValue"></param>
			/// <param name="errorValue"></param>
			/// <returns></returns>
			public static DateTime ObjToDate(this object thisValue, DateTime errorValue)
			{
			DateTime reval = DateTime.MinValue;
			if (thisValue != null && thisValue != DBNull.Value && DateTime.TryParse(thisValue.ToString(), out reval))
			{
			return reval;
			}

			return errorValue;
			}

			/// <summary>
			///
			/// </summary>
			/// <param name="thisValue"></param>
			/// <returns></returns>
			public static bool ObjToBool(this object thisValue)
			{
			bool reval = false;
			if (thisValue != null && thisValue != DBNull.Value && bool.TryParse(thisValue.ToString(), out reval))
			{
			return reval;
			}

			return reval;
			}


			/// <summary>
			/// è·åå½åæ¶é´çæ¶é´æ³
			/// </summary>
			/// <param name="thisValue"></param>
			/// <returns></returns>
			public static string DateToTimeStamp(this DateTime thisValue)
			{
			TimeSpan ts = thisValue - new DateTime(1970, 1, 1, 0, 0, 0, 0);
			return Convert.ToInt64(ts.TotalSeconds).ToString();
			}

			public static object ChangeType(this object value, Type type)
			{
			if (value == null && type.IsGenericType) return Activator.CreateInstance(type);
			if (value == null) return null;
			if (type == value.GetType()) return value;
			if (type.IsEnum)
			{
			if (value is string)
			return Enum.Parse(type, value as string);
			else
			return Enum.ToObject(type, value);
			}

			if (!type.IsInterface && type.IsGenericType)
			{
			Type innerType = type.GetGenericArguments()[0];
			object innerValue = ChangeType(value, innerType);
			return Activator.CreateInstance(type, new object[] { innerValue });
			}

			if (value is string && type == typeof(Guid)) return new Guid(value as string);
			if (value is string && type == typeof(Version)) return new Version(value as string);
			if (!(value is IConvertible)) return value;
			return Convert.ChangeType(value, type);
			}

			public static object ChangeTypeList(this object value, Type type)
			{
			if (value == null) return default;

			var gt = typeof(List<>).MakeGenericType(type);
			dynamic lis = Activator.CreateInstance(gt);

			var addMethod = gt.GetMethod("Add");
			string values = value.ToString();
			if (values != null && values.StartsWith("(") && values.EndsWith(")"))
			{
			string[] splits;
			if (values.Contains("\",\""))
			{
			splits = values.Remove(values.Length - 2, 2)
			.Remove(0, 2)
			.Split("\",\"");
			}
			else
			{
			splits = values.Remove(0, 1)
			.Remove(values.Length - 2, 1)
			.Split(",");
			}

			foreach (var split in splits)
			{
			var str = split;
			if (split.StartsWith("\"") && split.EndsWith("\""))
			{
			str = split.Remove(0, 1)
			.Remove(split.Length - 2, 1);
			}

			addMethod.Invoke(lis, new object[] { ChangeType(str, type) });
			}
			}

			return lis;
			}

			public static string ToJson(this object value)
			{
			return JsonConvert.SerializeObject(value);
			}

			public static bool IsNumeric(this object value)
			{
			if (value == null)
			return false;
			bool reslut = decimal.TryParse(value.ToString(), out decimal _number);
			return reslut;
			}

			public static bool IsInt(this object obj)
			{
			if (obj == null)
			return false;
			bool reslut = Int32.TryParse(obj.ToString(), out int _number);
			return reslut;

			}
			public static bool IsDate(this object str)
			{
			return str.IsDate(out _);
			}
			public static bool IsDate(this object str, out DateTime dateTime)
			{
			dateTime = DateTime.Now;
			if (str == null \|\| str.ToString() == "")
			{
			return false;
			}
			return DateTime.TryParse(str.ToString(), out dateTime);
			}

			/// <summary>
			/// æ ¹æ®ä¼ å¥æ ¼å¼å¤ææ¯å¦ä¸ºå°æ°
			/// </summary>
			/// <param name="str"></param>
			/// <param name="formatString">18,5</param>
			/// <returns></returns>
			public static bool IsNumber(this string str, string formatString)
			{
			if (string.IsNullOrEmpty(str)) return false;

			return Regex.IsMatch(str, @"^[+-]?\d[.]?\d$");
			}

			public static bool IsGuid(this string guid)
			{
			Guid newId;
			return guid.GetGuid(out newId);
			}

			public static bool GetGuid(this string guid, out Guid outId)
			{
			Guid emptyId = Guid.Empty;
			return Guid.TryParse(guid, out outId);
			}

			/// <summary>
			/// è½¬æ¢ä¸ºçæ´å qy 2024-7-15
			/// </summary>
			/// <param name="data">æ°æ®</param>
			public static short ToShort(this object data)
			{
			if (data == null)
			return 0;
			short result;
			var success = short.TryParse(data.ToString(), out result);
			if (success)
			return result;
			try
			{
			return Convert.ToInt16(data);
			}
			catch (Exception)
			{
			return 0;
			}
			}

			/// <summary>
			/// è½¬æ¢ä¸ºé«ç²¾åº¦æµ®ç¹æ°,å¹¶ææå®çå°æ°ä½4è5å¥ qy 2024-7-15
			/// </summary>
			/// <param name="data">æ°æ®</param>
			/// <param name="digits">å°æ°ä½æ°</param>
			public static decimal ToDecimal(this object data, int digits)
			{
			return Math.Round(ObjToDecimal(data), digits);
			}



			/// <summary>
			/// æä¸¾è½¬List qy 2024-7-15
			/// </summary>
			/// <typeparam name="T"></typeparam>
			/// <returns></returns>
			public static List<object> GetEnumList<T>()
			{
			List<object> list = new List<object>();
			var t = typeof(T);
			foreach (var item in Enum.GetValues(typeof(T)))
			{
			FieldInfo f = t.GetField(Enum.GetName(typeof(T), item));
			var r = (System.ComponentModel.DescriptionAttribute[])f.GetCustomAttributes(typeof(System.ComponentModel.DescriptionAttribute), false);
			list.Add(new { ID = item, value = Enum.GetName(typeof(T), item), name = r[0].Description });
			}
			return list;
			}

			/// <summary>
			/// éªè¯å¨æç±»ååç´ æ¯å¦ä¸ºç©º qy 2024-7-15
			/// </summary>
			/// <param name="obj"></param>
			/// <returns></returns>
			public static bool CheckDynamic(object obj)
			{
			return (obj != null && Convert.ToString(obj) != "") ? true : false;
			}

			/// <summary>
			/// å¨æç±»ååç´ è½¬åç¬¦ä¸²å¹¶è§£ç qy 2024-7-15
			/// </summary>
			/// <param name="obj"></param>
			/// <returns></returns>
			public static string DynamicToString(object obj)
			{
			return CheckDynamic(obj) ? HttpUtility.UrlDecode(Convert.ToString(obj).Trim()) : "";
			}

			/// <summary>
			/// DataTableè½¬ä¸ºjson qy 2024-7-15
			/// </summary>
			/// <param name="parObjRefDataTable">DataTable</param>
			/// <returns>jsonæ°æ®</returns>
			public static string ToJson(this DataTable parObjRefDataTable)
			{
			List<object> objArrList = new List<object>();

			foreach (DataRow objDataRow in parObjRefDataTable.Rows)
			{
			Dictionary<string, object> objResult = new Dictionary<string, object>();

			foreach (DataColumn objDataColumn in parObjRefDataTable.Columns)
			objResult.Add(objDataColumn.ColumnName, objDataRow[objDataColumn].ToString());

			objArrList.Add(objResult);
			}

			return ToJson(objArrList);
			}
			/// <summary>
			/// Jsonè½¬List qy 2024-7-15
			/// </summary>
			/// <typeparam name="T"></typeparam>
			/// <param name="parJson"></param>
			/// <returns></returns>
			public static List<T> JsonToList<T>(this string parJson)
			{
			if (string.IsNullOrWhiteSpace(parJson))
			{
			return new List<T>();
			}
			else
			{
			return JsonConvert.DeserializeObject<List<T>>(parJson);
			}
			}

			/// <summary>
			/// æ¥æè½¬ä¸ºunixå¼
			/// </summary>
			/// <param name="dt"></param>
			/// <param name="utc">T:æUTCæ¶é´è®¡ç®(é»è®¤);F:ææ¬å°æ¶é´è®¡ç®</param>
			/// <returns></returns>
			public static double ToUnix(this DateTime dt, bool utc = true)
			{
			double intResult = 0;
			System.DateTime startTime = TimeZone.CurrentTimeZone.ToLocalTime(new System.DateTime(1970, 1, 1));
			intResult = (dt - startTime).TotalSeconds;
			intResult = Math.Round(intResult, 0);
			return intResult;
			}

			#region å¤ææ¯å¦ä¸ºåç¬¦ä¸² qy 2024-7-15
			/// <summary>
			/// å¤æåç¬¦ä¸²æ¯å¦ä¸ºåæ³çjsonåç¬¦ä¸² qy 2024-7-15
			/// </summary>
			/// <param name="json"></param>
			/// <returns></returns>
			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;
			}

			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;
			}

			/// <summary>
			/// è·åå¼çé¿åº¦ï¼å½Jsonå¼åµå¥ä»¥"{"æ"["å¼å¤´æ¶ï¼ qy 2024-7-15
			/// </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>
			/// åç¬¦ç¶æ qy 2024-7-15
			/// </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åå½ä¸ºæ®éåç¬¦å¤çï¼ qy 2024-7-15
			/// </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;
			}

			#endregion

			public static LinqExpressionType GetLinqCondition(this string stringType)
			{
			LinqExpressionType linqExpression;
			switch (stringType)
			{
			case HtmlElementType.Contains:
			linqExpression = LinqExpressionType.In;
			break;
			case HtmlElementType.ThanOrEqual:
			linqExpression = LinqExpressionType.ThanOrEqual;
			break;
			case HtmlElementType.LessOrequal:
			linqExpression = LinqExpressionType.LessThanOrEqual;
			break;
			case HtmlElementType.GT:
			linqExpression = LinqExpressionType.GreaterThan;
			break;
			case HtmlElementType.lt:
			linqExpression = LinqExpressionType.LessThan;
			break;
			case HtmlElementType.like:
			linqExpression = LinqExpressionType.Contains;
			break;
			default:
			linqExpression = LinqExpressionType.Equal;
			break;
			}
			return linqExpression;
			}
			}
			}