httpClient调用方式

  1. namespace SOA.Common
  2. {
  3.     //httpClient调用WebApi
  4.     public class HttpClientHelper
  5.     {
  6.         public static string GetHttpClient(string serverUrl, string method, WebHeaderCollection header)
  7.         {
  8.             using (HttpClient client = new HttpClient())
  9.             {
  10.                 //如果有Basic认证的情况下，请自己封装header
  11.                 if (header != null)
  12.                     client.DefaultRequestHeaders.Add("Authorization", "BasicAuth " + header["Authorization"]);
  14.                 var response = client.GetAsync(serverUrl + method).Result; //拿到异步结果
  15.                 Console.WriteLine(response.StatusCode); //确保http成功
  16.                 return response.Content.ReadAsStringAsync().Result;
  17.             }
  18.         }
  20.         public static string PostHttpClient(string serverUrl, string method, Dictionary<string, string> param)
  21.         {
  22.             using (HttpClient client = new HttpClient())
  23.             {
  24.                 var content = new FormUrlEncodedContent(param);
  25.                 client.DefaultRequestHeaders.Add("user-agent",
  26.                     "Mozilla/5.0 (compatible; MSIE 10.0;     Windows NT 6.2; WOW64; Trident/6.0)");
  27.                 var response = client.PostAsync(serverUrl + method, content).Result; //拿到异步结果
  28.                 Console.WriteLine(response.StatusCode); //确保http成功
  29.                 return response.Content.ReadAsStringAsync().Result;
  30.             }
  31.         }
  33.         /// <summary>
  34.         /// httpClient使用代理
  35.         /// </summary>
  36.         /// <param name="serverUrl"></param>
  37.         /// <param name="method"></param>
  38.         /// <param name="param"></param>
  39.         /// <returns></returns>
  40.         public static string PostHttpClientWithProxy(string serverUrl, string method, Dictionary<string, string> param,
  41.             ProxyParam proxyParam)
  42.         {
  43.             HttpClientHandler aHandler = new HttpClientHandler();
  44.             aHandler.UseCookies = true;
  45.             aHandler.AllowAutoRedirect = true;
  46.             IWebProxy Proxya = new WebProxy(proxyParam.IP + ":" + proxyParam.Port);
  47.             Proxya.Credentials = new NetworkCredential(proxyParam.Name, proxyParam.Pass, proxyParam.Domain);
  48.             aHandler.Proxy = Proxya;
  50.             using (HttpClient client = new HttpClient(aHandler))
  51.             {
  52.                 var content = new FormUrlEncodedContent(param);
  53.                 client.DefaultRequestHeaders.Add("user-agent",
  54.                     "Mozilla/5.0 (compatible; MSIE 10.0;     Windows NT 6.2; WOW64; Trident/6.0)");
  55.                 var response = client.PostAsync(serverUrl + method, content).Result; //拿到异步结果
  56.                 Console.WriteLine(response.StatusCode); //确保http成功
  57.                 return response.Content.ReadAsStringAsync().Result;
  58.             }
  59.         }
  60.     }
  62.     public class ProxyParam
  63.     {
  64.         public string IP { get; set; }
  65.         public string Port { get; set; }
  66.         public string Name { get; set; }
  67.         public string Pass { get; set; }
  68.         public string Domain { get; set; }
  69.     }
  70. }

httpWebReqeust调用方式（一般使用）

  1. //WebRequest调用WebApi
  2.     public class WebRequestHelper
  3.     {
  5.         /// <summary>
  6.         ///   WebRequest的 Get 请求
  7.         /// </summary>
  8.         /// <param name="serverUrl" type="string">
  9.         ///     <para>
  10.         ///       api地址（地址+方法）
  11.         ///     </para>
  12.         /// </param>
  13.         /// <param name="paramData" type="string">
  14.         ///     <para>
  15.         ///       参数
  16.         ///     </para>
  17.         /// </param>
  18.         public static string GetWebRequest(string serverUrl, string paramData, WebHeaderCollection header)
  19.         {
  20.             string requestUrl = serverUrl;
  21.             if (serverUrl.IndexOf('?') == -1 && paramData.IndexOf('?') == -1)
  22.                 requestUrl += "?";
  23.             requestUrl += paramData;
  25.             HttpWebRequest request = (HttpWebRequest)WebRequest.Create(requestUrl);
  26.             if (header != null)
  27.                 request.Headers = header;
  28.             request.ContentType = "application/json";
  29.             request.Timeout = 30 * 1000;
  30.             request.Method = "GET";
  31.             string result = string.Empty;
  32.             using (var res = request.GetResponse() as HttpWebResponse)
  33.             {
  34.                 if (res.StatusCode == HttpStatusCode.OK)
  35.                 {
  36.                     var reader = new StreamReader(res.GetResponseStream(), Encoding.UTF8);
  37.                     result = reader.ReadToEnd();
  38.                 }
  39.                 return result;
  40.             }
  41.         }
  43.         /// <summary>
  44.         ///    WebRequest的 Post 请求
  45.         /// </summary>
  46.         /// <param name="serverUrl" type="string">
  47.         ///     <para>
  48.         ///       api地址（地址+方法）
  49.         ///     </para>
  50.         /// </param>
  51.         /// <param name="postData" type="string">
  52.         ///     <para>
  53.         ///     参数
  54.         ///     </para>
  55.         /// </param>
  56.         public static string PostWebRequest(string serverUrl, string postData, WebHeaderCollection header)
  57.         {
  58.             var dataArray = Encoding.UTF8.GetBytes(postData);
  59.             HttpWebRequest request = (HttpWebRequest)WebRequest.Create(serverUrl);
  60.             if (header != null)
  61.                 request.Headers = header;
  62.             request.ContentLength = dataArray.Length;
  63.             //设置上传服务的数据格式
  64.             request.ContentType = "application/json";
  65.             request.Timeout = 30 * 1000;
  66.             request.Method = "POST";
  68.             //创建输入流
  69.             Stream dataStream;
  70.             try
  71.             {
  72.                 dataStream = request.GetRequestStream();
  73.             }
  74.             catch (Exception)
  75.             {
  76.                 return null;//连接服务器失败
  77.             }
  78.             //发送请求
  79.             dataStream.Write(dataArray, 0, dataArray.Length);
  80.             dataStream.Close();
  82.             //读取返回值
  83.             string result = string.Empty;
  84.             using (var res = request.GetResponse() as HttpWebResponse)
  85.             {
  86.                 if (res.StatusCode == HttpStatusCode.OK)
  87.                 {
  88.                     var reader = new StreamReader(res.GetResponseStream(), Encoding.UTF8);
  89.                     result = reader.ReadToEnd();
  90.                 }
  91.                 return result;
  92.             }
  93.         }
  94.     }

封装的调用

  1. namespace SOA.Common
  2. {
  3.     public class ApiHelper
  4.     {
  5.         public static readonly ApiHelper Instance = new ApiHelper();
  6.         public string RequestApi(string method, string queryString, WebHeaderCollection header = null)
  7.         {
  8.             string result = WebRequestHelper.GetWebRequest(ConfigHelper.Config.ApiUrl + method, queryString, header);
  10.             return result;
  11.         }
  13.         public AjaxResult RequestApi<T>(string method, string queryString, WebHeaderCollection header = null)
  14.         {
  15.             var result = WebRequestHelper.GetWebRequest(ConfigHelper.Config.ApiUrl + method, queryString, header);
  17.             return SerializeResult<T>(result);
  18.         }
  20.         /// <summary>
  21.         /// 序列化结果
  22.         /// </summary>
  23.         /// <typeparam name="T"></typeparam>
  24.         /// <param name="result"></param>
  25.         /// <returns></returns>
  26.         private AjaxResult SerializeResult<T>(string result)
  27.         {
  28.             AjaxResult resultModel = JsonConverter.FromJsonTo<AjaxResult>(result);
  29.             if (resultModel.Status == 0 && resultModel.Data != null && !string.IsNullOrEmpty(resultModel.Data.ToString()))
  30.             {
  31.                 if (resultModel.Data.ToString().IndexOf("[") == 0 && StringHelper.IsJson(resultModel.Data.ToString()))
  32.                 {
  33.                     resultModel.Data = JsonConverter.FromJsonTo<List<T>>(resultModel.Data.ToString());
  34.                 }
  35.                 else if (StringHelper.IsJson(resultModel.Data.ToString()))
  36.                 {
  37.                     resultModel.Data = JsonConverter.FromJsonTo<T>(resultModel.Data.ToString());
  38.                 }
  39.             }
  40.             return resultModel;
  41.         }
  42.     }
  43. }

StringHelper.cs 帮助类

  1. namespace SOA.Common
  2. {
  3.     public class StringHelper
  4.     {
  5.         public static string AreaAttr(string defaultStr, int max = 0, string tipTitle = "", string tipid = "")
  6.         {
  7.             string text = "";
  8.             if (!string.IsNullOrWhiteSpace(defaultStr))
  9.             {
  10.                 text = text + " tipmsg=\"" + defaultStr + "\" onfocus=\"utils.ContentKeyFocus(this)\" onblur=\"utils.ContentKeyBlur(this)\"";
  11.                 text += " style=\"color:#999;\"";
  12.             }
  13.             if (max > 0)
  14.             {
  15.                 string text2 = text;
  16.                 text = string.Concat(new string[]
  17. 				{
  18. 					text2,
  19. 					" onkeyup=\"utils.ContentKeyUpDown2(this,",
  20. 					max.ToString(),
  21. 					",'",
  22. 					tipid,
  23. 					"',0,'",
  24. 					tipTitle,
  25. 					"')\""
  26. 				});
  27.             }
  28.             return text;
  29.         }
  30.         public static string InputAttr(string val, string defaultStr, int max = 0, string tipTitle = "", string tipid = "")
  31.         {
  32.             string text = "";
  33.             if (!string.IsNullOrWhiteSpace(val))
  34.             {
  35.                 text = text + " value=\"" + val + "\"";
  36.             }
  37.             if (!string.IsNullOrWhiteSpace(defaultStr))
  38.             {
  39.                 if (string.IsNullOrWhiteSpace(val))
  40.                 {
  41.                     text = text + " value=\"" + defaultStr + "\"";
  42.                 }
  43.                 text = text + " tipmsg=\"" + defaultStr + "\" onfocus=\"utils.ContentKeyFocus(this)\" onblur=\"utils.ContentKeyBlur(this)\"";
  44.                 text += " style=\"color:#999;\"";
  45.             }
  46.             if (max > 0)
  47.             {
  48.                 string text2 = text;
  49.                 text = string.Concat(new string[]
  50. 				{
  51. 					text2,
  52. 					" onkeyup=\"utils.ContentKeyUpDown2(this,",
  53. 					max.ToString(),
  54. 					",'",
  55. 					tipid,
  56. 					"',0,'",
  57. 					tipTitle,
  58. 					"')\""
  59. 				});
  60.             }
  61.             return text;
  62.         }
  63.         public static string WapEncode(string source)
  64.         {
  65.             return (!string.IsNullOrEmpty(source)) ? source.Replace("&", "&amp;").Replace("<", "&lt;").Replace(">", "&gt;").Replace("‘", "&apos;").Replace("\"", "&quot;").Replace("$", "$").Replace(" ", "&nbsp;") : "";
  66.         }
  67.         public static string SubStr(string srcStr, int len)
  68.         {
  69.             string result;
  70.             if (len < 1)
  71.             {
  72.                 result = string.Empty;
  73.             }
  74.             else
  75.             {
  76.                 if (string.IsNullOrEmpty(srcStr))
  77.                 {
  78.                     result = srcStr;
  79.                 }
  80.                 else
  81.                 {
  82.                     int byteCount = System.Text.Encoding.Default.GetByteCount(srcStr);
  83.                     if (byteCount <= len)
  84.                     {
  85.                         result = srcStr;
  86.                     }
  87.                     else
  88.                     {
  89.                         int num = 0;
  90.                         int num2 = 0;
  91.                         char[] array = srcStr.ToCharArray();
  92.                         char[] array2 = array;
  93.                         for (int i = 0; i < array2.Length; i++)
  94.                         {
  95.                             char c = array2[i];
  96.                             int byteCount2 = System.Text.Encoding.Default.GetByteCount(array, num2, 1);
  97.                             int num3 = num + byteCount2;
  98.                             if (num3 > len)
  99.                             {
  100.                                 result = srcStr.Substring(0, num2) + "...";
  101.                                 return result;
  102.                             }
  103.                             num = num3;
  104.                             num2++;
  105.                         }
  106.                         result = srcStr;
  107.                     }
  108.                 }
  109.             }
  110.             return result;
  111.         }
  112.         public static string ReplaceIDS(string oldIds, bool isNoZero = true)
  113.         {
  114.             string result;
  115.             if (string.IsNullOrWhiteSpace(oldIds))
  116.             {
  117.                 result = "";
  118.             }
  119.             else
  120.             {
  121.                 string[] array = oldIds.Trim().Trim(new char[]
  122. 				{
  123. 					','
  124. 				}).Split(new char[]
  125. 				{
  126. 					','
  127. 				});
  128.                 System.Collections.Generic.List<long> list = new System.Collections.Generic.List<long>();
  129.                 string[] array2 = array;
  130.                 for (int i = 0; i < array2.Length; i++)
  131.                 {
  132.                     string text = array2[i];
  133.                     long num = TypeHelper.StrToInt64(text.Trim(), 0L);
  134.                     if (!isNoZero || num != 0L)
  135.                     {
  136.                         if (!list.Contains(num))
  137.                         {
  138.                             list.Add(num);
  139.                         }
  140.                     }
  141.                 }
  142.                 string text2 = "";
  143.                 foreach (long current in list)
  144.                 {
  145.                     text2 = text2 + "," + current.ToString();
  146.                 }
  147.                 result = text2.Trim(new char[]
  148. 				{
  149. 					','
  150. 				});
  151.             }
  152.             return result;
  153.         }
  154.         public static string ReplaceStr2(string sourceStr)
  155.         {
  156.             string result;
  157.             if (string.IsNullOrWhiteSpace(sourceStr))
  158.             {
  159.                 result = sourceStr;
  160.             }
  161.             else
  162.             {
  163.                 result = sourceStr.Trim().Replace(" ", "").Replace("'", "").Replace("\"", "");
  164.             }
  165.             return result;
  166.         }
  167.         public static string Cut(string str, int len, System.Text.Encoding encoding)
  168.         {
  169.             string result;
  170.             if (string.IsNullOrEmpty(str))
  171.             {
  172.                 result = str;
  173.             }
  174.             else
  175.             {
  176.                 if (len <= 0)
  177.                 {
  178.                     result = string.Empty;
  179.                 }
  180.                 else
  181.                 {
  182.                     int byteCount = encoding.GetByteCount(str);
  183.                     if (byteCount > len)
  184.                     {
  185.                         bool flag = byteCount == str.Length;
  186.                         if (flag)
  187.                         {
  188.                             result = str.Substring(0, len);
  189.                             return result;
  190.                         }
  191.                         int num = 0;
  192.                         int num2 = 0;
  193.                         char[] array = str.ToCharArray();
  194.                         char[] array2 = array;
  195.                         for (int i = 0; i < array2.Length; i++)
  196.                         {
  197.                             char c = array2[i];
  198.                             int byteCount2 = encoding.GetByteCount(array, num2, 1);
  199.                             int num3 = num + byteCount2;
  200.                             if (num3 > len)
  201.                             {
  202.                                 result = str.Substring(0, num2);
  203.                                 return result;
  204.                             }
  205.                             num = num3;
  206.                             num2++;
  207.                         }
  208.                     }
  209.                     result = str;
  210.                 }
  211.             }
  212.             return result;
  213.         }
  214.         public static int GetChineseLength(string s)
  215.         {
  216.             int result;
  217.             if (string.IsNullOrEmpty(s))
  218.             {
  219.                 result = 0;
  220.             }
  221.             else
  222.             {
  223.                 result = System.Text.Encoding.GetEncoding("gb2312").GetByteCount(s);
  224.             }
  225.             return result;
  226.         }
  227.         public static int GetUTF8Length(string s)
  228.         {
  229.             int result;
  230.             if (string.IsNullOrEmpty(s))
  231.             {
  232.                 result = 0;
  233.             }
  234.             else
  235.             {
  236.                 result = System.Text.Encoding.UTF8.GetByteCount(s);
  237.             }
  238.             return result;
  239.         }
  240.         public static string StrFormat(string str)
  241.         {
  242.             string result;
  243.             if (str == null)
  244.             {
  245.                 result = "";
  246.             }
  247.             else
  248.             {
  249.                 str = str.Replace("\r\n", "<br />");
  250.                 str = str.Replace("\n", "<br />");
  251.                 result = str;
  252.             }
  253.             return result;
  254.         }
  255.         public static string EncodeHtml(string strHtml)
  256.         {
  257.             string result;
  258.             if (strHtml != "")
  259.             {
  260.                 strHtml = strHtml.Replace(",", "&def");
  261.                 strHtml = strHtml.Replace("'", "&dot");
  262.                 strHtml = strHtml.Replace(";", "&dec");
  263.                 result = strHtml;
  264.             }
  265.             else
  266.             {
  267.                 result = "";
  268.             }
  269.             return result;
  270.         }
  271.         public static string HtmlDecode(string str)
  272.         {
  273.             return HttpUtility.HtmlDecode(str);
  274.         }
  275.         public static string HtmlEncode(string str)
  276.         {
  277.             return HttpUtility.HtmlEncode(str);
  278.         }
  279.         public static string UrlEncode(string str)
  280.         {
  281.             return HttpUtility.UrlEncode(str);
  282.         }
  283.         public static string UrlDecode(string str)
  284.         {
  285.             return HttpUtility.UrlDecode(str);
  286.         }
  288.         public static bool StrIsNullOrEmpty(string str)
  289.         {
  290.             return str == null || str.Trim() == string.Empty;
  291.         }
  292.         public static string CutString(string str, int startIndex, int length)
  293.         {
  294.             string result;
  295.             if (string.IsNullOrWhiteSpace(str))
  296.             {
  297.                 result = "";
  298.             }
  299.             else
  300.             {
  301.                 if (startIndex >= 0)
  302.                 {
  303.                     if (length < 0)
  304.                     {
  305.                         length *= -1;
  306.                         if (startIndex - length < 0)
  307.                         {
  308.                             length = startIndex;
  309.                             startIndex = 0;
  310.                         }
  311.                         else
  312.                         {
  313.                             startIndex -= length;
  314.                         }
  315.                     }
  316.                     if (startIndex > str.Length)
  317.                     {
  318.                         result = "";
  319.                         return result;
  320.                     }
  321.                 }
  322.                 else
  323.                 {
  324.                     if (length < 0)
  325.                     {
  326.                         result = "";
  327.                         return result;
  328.                     }
  329.                     if (length + startIndex <= 0)
  330.                     {
  331.                         result = "";
  332.                         return result;
  333.                     }
  334.                     length += startIndex;
  335.                     startIndex = 0;
  336.                 }
  337.                 if (str.Length - startIndex < length)
  338.                 {
  339.                     length = str.Length - startIndex;
  340.                 }
  341.                 result = str.Substring(startIndex, length);
  342.             }
  343.             return result;
  344.         }
  345.         public static string CutString(string str, int startIndex)
  346.         {
  347.             string result;
  348.             if (string.IsNullOrWhiteSpace(str))
  349.             {
  350.                 result = "";
  351.             }
  352.             else
  353.             {
  354.                 result = StringHelper.CutString(str, startIndex, str.Length);
  355.             }
  356.             return result;
  357.         }
  359.         public static string ToSqlInStr(System.Collections.Generic.List<int> ids)
  360.         {
  361.             string text = "";
  362.             if (ids != null && ids.Count > 0)
  363.             {
  364.                 foreach (int current in ids)
  365.                 {
  366.                     text = text + current + ",";
  367.                 }
  368.             }
  369.             text = text.Trim(",".ToCharArray());
  370.             return text;
  371.         }
  372.         public static string ToSqlInStr(System.Collections.Generic.List<long> ids)
  373.         {
  374.             string text = "";
  375.             if (ids != null && ids.Count > 0)
  376.             {
  377.                 foreach (long current in ids)
  378.                 {
  379.                     text = text + current + ",";
  380.                 }
  381.             }
  382.             text = text.Trim(",".ToCharArray());
  383.             return text;
  384.         }
  385.         public static string ToSqlInStr(System.Collections.Generic.List<string> ids)
  386.         {
  387.             string text = "";
  388.             if (ids != null && ids.Count > 0)
  389.             {
  390.                 foreach (string current in ids)
  391.                 {
  392.                     text = text + "'" + current + "',";
  393.                 }
  394.             }
  395.             text = text.Trim(",".ToCharArray());
  396.             return text;
  397.         }
  398.         public static string FilteSQLStr(string Str)
  399.         {
  400.             string result;
  401.             if (string.IsNullOrEmpty(Str))
  402.             {
  403.                 result = "";
  404.             }
  405.             else
  406.             {
  407.                 Str = Str.Replace("'", "");
  408.                 Str = Str.Replace("\"", "");
  409.                 Str = Str.Replace("&", "&amp");
  410.                 Str = Str.Replace("<", "&lt");
  411.                 Str = Str.Replace(">", "&gt");
  412.                 Str = Str.Replace("delete", "");
  413.                 Str = Str.Replace("update", "");
  414.                 Str = Str.Replace("insert", "");
  415.                 result = Str;
  416.             }
  417.             return result;
  418.         }
  420.         private static bool IsJsonStart(ref string json)
  421.         {
  422.             if (!string.IsNullOrEmpty(json))
  423.             {
  424.                 json = json.Trim('\r', '\n', ' ');
  425.                 if (json.Length > 1)
  426.                 {
  427.                     char s = json[0];
  428.                     char e = json[json.Length - 1];
  429.                     return (s == '{' && e == '}') || (s == '[' && e == ']');
  430.                 }
  431.             }
  432.             return false;
  433.         }
  434.         internal static bool IsJson(string json)
  435.         {
  436.             int errIndex;
  437.             return IsJson(json, out errIndex);
  438.         }
  439.         internal static bool IsJson(string json, out int errIndex)
  440.         {
  441.             errIndex = 0;
  442.             if (IsJsonStart(ref json))
  443.             {
  444.                 CharState cs = new CharState();
  445.                 char c;
  446.                 for (int i = 0; i < json.Length; i++)
  447.                 {
  448.                     c = json[i];
  449.                     if (SetCharState(c, ref cs) && cs.childrenStart)//设置关键符号状态。
  450.                     {
  451.                         string item = json.Substring(i);
  452.                         int err;
  453.                         int length = GetValueLength(item, true, out err);
  454.                         cs.childrenStart = false;
  455.                         if (err > 0)
  456.                         {
  457.                             errIndex = i + err;
  458.                             return false;
  459.                         }
  460.                         i = i + length - 1;
  461.                     }
  462.                     if (cs.isError)
  463.                     {
  464.                         errIndex = i;
  465.                         return false;
  466.                     }
  467.                 }
  469.                 return !cs.arrayStart && !cs.jsonStart;
  470.             }
  471.             return false;
  472.         }
  474.         /// <summary>
  475.         /// 获取值的长度（当Json值嵌套以"{"或"["开头时）
  476.         /// </summary>
  477.         private static int GetValueLength(string json, bool breakOnErr, out int errIndex)
  478.         {
  479.             errIndex = 0;
  480.             int len = 0;
  481.             if (!string.IsNullOrEmpty(json))
  482.             {
  483.                 CharState cs = new CharState();
  484.                 char c;
  485.                 for (int i = 0; i < json.Length; i++)
  486.                 {
  487.                     c = json[i];
  488.                     if (!SetCharState(c, ref cs))//设置关键符号状态。
  489.                     {
  490.                         if (!cs.jsonStart && !cs.arrayStart)//json结束，又不是数组，则退出。
  491.                         {
  492.                             break;
  493.                         }
  494.                     }
  495.                     else if (cs.childrenStart)//正常字符，值状态下。
  496.                     {
  497.                         int length = GetValueLength(json.Substring(i), breakOnErr, out errIndex);//递归子值，返回一个长度。。。
  498.                         cs.childrenStart = false;
  499.                         cs.valueStart = 0;
  500.                         //cs.state = 0;
  501.                         i = i + length - 1;
  502.                     }
  503.                     if (breakOnErr && cs.isError)
  504.                     {
  505.                         errIndex = i;
  506.                         return i;
  507.                     }
  508.                     if (!cs.jsonStart && !cs.arrayStart)//记录当前结束位置。
  509.                     {
  510.                         len = i + 1;//长度比索引+1
  511.                         break;
  512.                     }
  513.                 }
  514.             }
  515.             return len;
  516.         }
  517.         /// <summary>
  518.         /// 字符状态
  519.         /// </summary>
  520.         private class CharState
  521.         {
  522.             internal bool jsonStart = false;//以 "{"开始了...
  523.             internal bool setDicValue = false;// 可以设置字典值了。
  524.             internal bool escapeChar = false;//以"\"转义符号开始了
  525.             /// <summary>
  526.             /// 数组开始【仅第一开头才算】，值嵌套的以【childrenStart】来标识。
  527.             /// </summary>
  528.             internal bool arrayStart = false;//以"[" 符号开始了
  529.             internal bool childrenStart = false;//子级嵌套开始了。
  530.             /// <summary>
  531.             /// 【0 初始状态，或 遇到“,”逗号】；【1 遇到“：”冒号】
  532.             /// </summary>
  533.             internal int state = 0;
  535.             /// <summary>
  536.             /// 【-1 取值结束】【0 未开始】【1 无引号开始】【2 单引号开始】【3 双引号开始】
  537.             /// </summary>
  538.             internal int keyStart = 0;
  539.             /// <summary>
  540.             /// 【-1 取值结束】【0 未开始】【1 无引号开始】【2 单引号开始】【3 双引号开始】
  541.             /// </summary>
  542.             internal int valueStart = 0;
  543.             internal bool isError = false;//是否语法错误。
  545.             internal void CheckIsError(char c)//只当成一级处理（因为GetLength会递归到每一个子项处理）
  546.             {
  547.                 if (keyStart > 1 || valueStart > 1)
  548.                 {
  549.                     return;
  550.                 }
  551.                 //示例 ["aa",{"bbbb":123,"fff","ddd"}]
  552.                 switch (c)
  553.                 {
  554.                     case '{'://[{ "[{A}]":[{"[{B}]":3,"m":"C"}]}]
  555.                         isError = jsonStart && state == 0;//重复开始错误 同时不是值处理。
  556.                         break;
  557.                     case '}':
  558.                         isError = !jsonStart || (keyStart != 0 && state == 0);//重复结束错误 或者 提前结束{"aa"}。正常的有{}
  559.                         break;
  560.                     case '[':
  561.                         isError = arrayStart && state == 0;//重复开始错误
  562.                         break;
  563.                     case ']':
  564.                         isError = !arrayStart || jsonStart;//重复开始错误 或者 Json 未结束
  565.                         break;
  566.                     case '"':
  567.                     case '\'':
  568.                         isError = !(jsonStart || arrayStart); //json 或数组开始。
  569.                         if (!isError)
  570.                         {
  571.                             //重复开始 [""",{"" "}]
  572.                             isError = (state == 0 && keyStart == -1) || (state == 1 && valueStart == -1);
  573.                         }
  574.                         if (!isError && arrayStart && !jsonStart && c == '\'')//['aa',{}]
  575.                         {
  576.                             isError = true;
  577.                         }
  578.                         break;
  579.                     case ':':
  580.                         isError = !jsonStart || state == 1;//重复出现。
  581.                         break;
  582.                     case ',':
  583.                         isError = !(jsonStart || arrayStart); //json 或数组开始。
  584.                         if (!isError)
  585.                         {
  586.                             if (jsonStart)
  587.                             {
  588.                                 isError = state == 0 || (state == 1 && valueStart > 1);//重复出现。
  589.                             }
  590.                             else if (arrayStart)//["aa,] [,]  [{},{}]
  591.                             {
  592.                                 isError = keyStart == 0 && !setDicValue;
  593.                             }
  594.                         }
  595.                         break;
  596.                     case ' ':
  597.                     case '\r':
  598.                     case '\n'://[ "a",\r\n{} ]
  599.                     case '\0':
  600.                     case '\t':
  601.                         break;
  602.                     default: //值开头。。
  603.                         isError = (!jsonStart && !arrayStart) || (state == 0 && keyStart == -1) || (valueStart == -1 && state == 1);//
  604.                         break;
  605.                 }
  606.                 //if (isError)
  607.                 //{
  609.                 //}
  610.             }
  611.         }
  612.         /// <summary>
  613.         /// 设置字符状态(返回true则为关键词，返回false则当为普通字符处理）
  614.         /// </summary>
  615.         private static bool SetCharState(char c, ref CharState cs)
  616.         {
  617.             cs.CheckIsError(c);
  618.             switch (c)
  619.             {
  620.                 case '{'://[{ "[{A}]":[{"[{B}]":3,"m":"C"}]}]
  621.                     #region 大括号
  622.                     if (cs.keyStart <= 0 && cs.valueStart <= 0)
  623.                     {
  624.                         cs.keyStart = 0;
  625.                         cs.valueStart = 0;
  626.                         if (cs.jsonStart && cs.state == 1)
  627.                         {
  628.                             cs.childrenStart = true;
  629.                         }
  630.                         else
  631.                         {
  632.                             cs.state = 0;
  633.                         }
  634.                         cs.jsonStart = true;//开始。
  635.                         return true;
  636.                     }
  637.                     #endregion
  638.                     break;
  639.                 case '}':
  640.                     #region 大括号结束
  641.                     if (cs.keyStart <= 0 && cs.valueStart < 2 && cs.jsonStart)
  642.                     {
  643.                         cs.jsonStart = false;//正常结束。
  644.                         cs.state = 0;
  645.                         cs.keyStart = 0;
  646.                         cs.valueStart = 0;
  647.                         cs.setDicValue = true;
  648.                         return true;
  649.                     }
  650.                     // cs.isError = !cs.jsonStart && cs.state == 0;
  651.                     #endregion
  652.                     break;
  653.                 case '[':
  654.                     #region 中括号开始
  655.                     if (!cs.jsonStart)
  656.                     {
  657.                         cs.arrayStart = true;
  658.                         return true;
  659.                     }
  660.                     else if (cs.jsonStart && cs.state == 1)
  661.                     {
  662.                         cs.childrenStart = true;
  663.                         return true;
  664.                     }
  665.                     #endregion
  666.                     break;
  667.                 case ']':
  668.                     #region 中括号结束
  669.                     if (cs.arrayStart && !cs.jsonStart && cs.keyStart <= 2 && cs.valueStart <= 0)//[{},333]//这样结束。
  670.                     {
  671.                         cs.keyStart = 0;
  672.                         cs.valueStart = 0;
  673.                         cs.arrayStart = false;
  674.                         return true;
  675.                     }
  676.                     #endregion
  677.                     break;
  678.                 case '"':
  679.                 case '\'':
  680.                     #region 引号
  681.                     if (cs.jsonStart || cs.arrayStart)
  682.                     {
  683.                         if (cs.state == 0)//key阶段,有可能是数组["aa",{}]
  684.                         {
  685.                             if (cs.keyStart <= 0)
  686.                             {
  687.                                 cs.keyStart = (c == '"' ? 3 : 2);
  688.                                 return true;
  689.                             }
  690.                             else if ((cs.keyStart == 2 && c == '\'') || (cs.keyStart == 3 && c == '"'))
  691.                             {
  692.                                 if (!cs.escapeChar)
  693.                                 {
  694.                                     cs.keyStart = -1;
  695.                                     return true;
  696.                                 }
  697.                                 else
  698.                                 {
  699.                                     cs.escapeChar = false;
  700.                                 }
  701.                             }
  702.                         }
  703.                         else if (cs.state == 1 && cs.jsonStart)//值阶段必须是Json开始了。
  704.                         {
  705.                             if (cs.valueStart <= 0)
  706.                             {
  707.                                 cs.valueStart = (c == '"' ? 3 : 2);
  708.                                 return true;
  709.                             }
  710.                             else if ((cs.valueStart == 2 && c == '\'') || (cs.valueStart == 3 && c == '"'))
  711.                             {
  712.                                 if (!cs.escapeChar)
  713.                                 {
  714.                                     cs.valueStart = -1;
  715.                                     return true;
  716.                                 }
  717.                                 else
  718.                                 {
  719.                                     cs.escapeChar = false;
  720.                                 }
  721.                             }
  723.                         }
  724.                     }
  725.                     #endregion
  726.                     break;
  727.                 case ':':
  728.                     #region 冒号
  729.                     if (cs.jsonStart && cs.keyStart < 2 && cs.valueStart < 2 && cs.state == 0)
  730.                     {
  731.                         if (cs.keyStart == 1)
  732.                         {
  733.                             cs.keyStart = -1;
  734.                         }
  735.                         cs.state = 1;
  736.                         return true;
  737.                     }
  738.                     // cs.isError = !cs.jsonStart || (cs.keyStart < 2 && cs.valueStart < 2 && cs.state == 1);
  739.                     #endregion
  740.                     break;
  741.                 case ',':
  742.                     #region 逗号 //["aa",{aa:12,}]
  744.                     if (cs.jsonStart)
  745.                     {
  746.                         if (cs.keyStart < 2 && cs.valueStart < 2 && cs.state == 1)
  747.                         {
  748.                             cs.state = 0;
  749.                             cs.keyStart = 0;
  750.                             cs.valueStart = 0;
  751.                             //if (cs.valueStart == 1)
  752.                             //{
  753.                             //    cs.valueStart = 0;
  754.                             //}
  755.                             cs.setDicValue = true;
  756.                             return true;
  757.                         }
  758.                     }
  759.                     else if (cs.arrayStart && cs.keyStart <= 2)
  760.                     {
  761.                         cs.keyStart = 0;
  762.                         //if (cs.keyStart == 1)
  763.                         //{
  764.                         //    cs.keyStart = -1;
  765.                         //}
  766.                         return true;
  767.                     }
  768.                     #endregion
  769.                     break;
  770.                 case ' ':
  771.                 case '\r':
  772.                 case '\n'://[ "a",\r\n{} ]
  773.                 case '\0':
  774.                 case '\t':
  775.                     if (cs.keyStart <= 0 && cs.valueStart <= 0) //cs.jsonStart &&
  776.                     {
  777.                         return true;//跳过空格。
  778.                     }
  779.                     break;
  780.                 default: //值开头。。
  781.                     if (c == '\\') //转义符号
  782.                     {
  783.                         if (cs.escapeChar)
  784.                         {
  785.                             cs.escapeChar = false;
  786.                         }
  787.                         else
  788.                         {
  789.                             cs.escapeChar = true;
  790.                             return true;
  791.                         }
  792.                     }
  793.                     else
  794.                     {
  795.                         cs.escapeChar = false;
  796.                     }
  797.                     if (cs.jsonStart || cs.arrayStart) // Json 或数组开始了。
  798.                     {
  799.                         if (cs.keyStart <= 0 && cs.state == 0)
  800.                         {
  801.                             cs.keyStart = 1;//无引号的
  802.                         }
  803.                         else if (cs.valueStart <= 0 && cs.state == 1 && cs.jsonStart)//只有Json开始才有值。
  804.                         {
  805.                             cs.valueStart = 1;//无引号的
  806.                         }
  807.                     }
  808.                     break;
  809.             }
  810.             return false;
  811.         }
  812.     }
  813. }

WebApi的调用-2.后台调用的更多相关文章

  1. c#后台调用API

    前两周赶上项目第一个版本上线,着实忙了一把,毕竟只有两个人负责.如今已完结,总算喘了一口气,现在任务就是写API.测API,许久之前写过JS前台调用 项目API,也写过后台调用开放的手机号归属地查询, ...

  2. 使用OAuth、Identity创建WebApi认证接口供客户端调用

    前言 现在的web app基本上都是前后端分离,之前接触的大部分应用场景最终产品都是部署在同一个站点下,那么随着WebApi(Restful api)的发展前后端实现的完全分离,前端不在后端框架的页面 ...

  3. 获取ip ,百度地图坐标点 和 在 后台调用 url()

        protected  void getip()         {             string ips = HttpContext.Current.Request.UserHostA ...

  4. 由ASP.NET所谓前台调用后台、后台调用前台想到HTTP——实践篇（二）

    在由ASP.NET所谓前台调用后台.后台调用前台想到HTTP——理论篇中描述了一下ASP.NET新手的三个问题及相关的HTTP协议内容,在由ASP.NET所谓前台调用后台.后台调用前台想到HTTP—— ...

  5. 由ASP.NET所谓前台调用后台、后台调用前台想到HTTP——理论篇

    工作两年多了,我会经常尝试给公司小伙伴儿们解决一些问题,几个月下来我发现初入公司的小朋友最爱问的问题就三个 1. 我想前台调用后台的XXX方法怎么弄啊? 2. 我想后台调用前台的XXX JavaScr ...

  6. Javascript调用C#后台方法及JSon解析

    Javascript调用C#后台方法及JSon解析   如何使用Ajax 调用C# 后台方法. 本文目录 如何使用Ajax 调用C# 后台方法. 1.后台(.cs)测试方法 2.前台调用(javasc ...

  7. WebService – 3.后台调用WebService，根级别上的数据无效

    1.因为我的webservice返回的是json, 2.ajax传递跨域不安全, 3.contentType: "application/json; charset=utf-8", ...

  8. Http下的各种操作类.WebApi系列~通过HttpClient来调用Web Api接口

    1.WebApi系列~通过HttpClient来调用Web Api接口 http://www.cnblogs.com/lori/p/4045413.html HttpClient使用详解(java版本 ...

  9. js前台与后台数据交互-后台调前台（后台调用、注册客户端脚本）

    转自:http://blog.csdn.net/wang379275614/article/details/17049721 客户端脚本一般都在前台,这里讲的是(1)在后台调用前台定义的脚本(2)在后 ...

随机推荐

  1. SQL记录-Oracle重命名表名例子

    rename table_1 to table_2

  2. MVC模块化开发方案

    核心: 主要利用MVC的区域功能,实现项目模块独立开发和调试. 目标: 各个模块以独立MVC应用程序存在,即模块可独立开发和调试. 动态注册各个模块路由. 一:新建解决方案目录结构 如图: 二:Eas ...

  3. C# 实现线段的编码裁剪算法（vs2010）

    using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; usin ...

  4. FASTREPORT COM/ActiveX报表如何保存到C++项目中？

    可以的. VC++ : ... IStream * pStream;CreateStreamOnHGlobal(NULL, true, &pStream);pStream->AddRef ...

  5. js 碰撞 + 重力 运动

    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/ ...

  6. JavaScript之Ajax(一)创建Ajax对象

    // 支持浏览器的源码 function AjaxObject() { var AjaxRequest; // 缓存XHR对象便于 Ajax 使用 try { // Opera 8.0+, Firef ...

  7. JavaScript之字符串匹配工具[插件]

    /*** * StringCheckUtil * 字符串检测工具 * * @version 1.0 * @method isNum(string,scope) * @method isChinese( ...

  8. Mysql 插入中文错误：Incorrect string value: '\xE7\xA8\x8B\xE5\xBA\x8F...' for column 'course' at row 1

    create table my_user (    id tinyint(4) not null auto_increment,    account varchar(255) default nul ...

  9. 函数前加static与不加static的区别

    1:加了static后表示该函数失去了全局可见性,只在该函数所在的文件作用域内可见 2:当函数声明为static以后,编译器在该目标编译单元内只含有该函数的入口地址,没有函数名,其它编译单元便不能通过 ...

  10. python3之协程

    1.协程的概念 协程,又称微线程,纤程.英文名Coroutine. 线程是系统级别的它们由操作系统调度,而协程则是程序级别的由程序根据需要自己调度.在一个线程中会有很多函数,我们把这些函数称为子程序, ...