如何使用ASP.NET實(shí)現(xiàn)微信JS-SDK支付

小編給大家分享一下如何使用ASP.NET實(shí)現(xiàn)微信JS-SDK支付，希望大家閱讀完這篇文章之后都有所收獲，下面讓我們一起去探討吧！

模型層實(shí)體類(lèi):

 public class JsEntities
 {
 /// <summary>
 /// 公眾號(hào)id
 /// </summary>
 public string appId { get; set; }
 /// <summary>
 /// 時(shí)間戳
 /// </summary>
 public string timeStamp { get; set; }
 /// <summary>
 /// 隨機(jī)字符串
 /// </summary>
 public string nonceStr { get; set; }
 /// <summary>
 /// 訂單詳情擴(kuò)展字符串
 /// </summary>
 public string package { get; set; }
 /// <summary>
 /// 簽名類(lèi)型
 /// </summary>
 public string signType { get; set; }

 /// <summary>
 /// 簽名
 /// </summary>
 public string paySign { get; set; }

 }

 public class UnifyEntities
 {
 /// <summary>
 /// 公眾賬號(hào)ID
 /// </summary>
 public string appid { get; set; }
 /// <summary>
 /// 微信支付分配的商戶(hù)號(hào)
 /// </summary>
 public string mch_id { get; set; }
 /// <summary>
 /// 微信支付分配的終端設(shè)備號(hào)
 /// </summary>
 public string device_info { get; set; }
 /// <summary>
 /// 隨機(jī)字符串，不長(zhǎng)于32位
 /// </summary>
 public string nonce_str { get; set; }
 /// <summary>
 /// 簽名
 /// </summary>
 public string sign { get; set; }
 /// <summary>
 /// 商品描述最大長(zhǎng)度127
 /// </summary>
 public string body { get; set; }
 /// <summary>
 /// 附加數(shù)據(jù)，原樣返回
 /// </summary>
 public string attach { get; set; }
 /// <summary>
 /// 商戶(hù)系統(tǒng)內(nèi)部的訂單號(hào),32 個(gè)字符內(nèi)、可包含字母,確保在商戶(hù)系統(tǒng)唯一,詳細(xì)說(shuō)明
 /// </summary>
 public string out_trade_no { get; set; }
 /// <summary>
 /// 訂單總金額，單位為分，不能帶小數(shù)點(diǎn)
 /// </summary>
 public string total_fee { get; set; }
 /// <summary>
 /// 終端IP
 /// </summary>
 public string spbill_create_ip { get; set; }
 /// <summary>
 /// 交易起始時(shí)間
 /// </summary>
 public string time_start { get; set; }
 /// <summary>
 /// 交易結(jié)束時(shí)間
 /// </summary>
 public string time_expire { get; set; }
 /// <summary>
 /// 接收微信支付成功通知
 /// </summary>
 public string notify_url { get; set; }
 /// <summary>
 /// JSAPI、NATIVE、APP
 /// </summary>
 public string trade_type { get; set; }
 /// <summary>
 /// 用戶(hù)在商戶(hù)appid下的唯一標(biāo)識(shí)，trade_type為JSAPI 時(shí)，此參數(shù)必傳
 /// </summary>
 public string openid { get; set; }
 /// <summary>
 /// 只在 trade_type 為 NATIVE 時(shí)需要填寫(xiě)。此id為二維碼中包含的商品ID，商戶(hù)自行維護(hù)。
 /// </summary>
 public string product_id { get; set; }
 }

 public class UnifyReceive
 {
 /// <summary>
 /// SUCCESS/FAIL此字段是通信標(biāo)識(shí)，非交易標(biāo)識(shí)，交易是否成功需要查看result_code來(lái)判斷
 /// </summary>
 public string return_code { get; set; }
 /// <summary>
 /// 返回信息，如非空，為錯(cuò)誤原因
 /// </summary>
 public string return_msg { get; set; }
 /// <summary>
 /// 微信分配的公眾賬號(hào)ID
 /// </summary>
 public string appid { get; set; }
 /// <summary>
 /// 微信支付分配的商戶(hù)號(hào)
 /// </summary>
 public string mch_id { get; set; }
 /// <summary>
 /// 隨機(jī)字符串，不長(zhǎng)于32位
 /// </summary>
 public string nonce_str { get; set; }
 /// <summary>
 /// 簽名
 /// </summary>
 public string sign { get; set; }
 /// <summary>
 /// 業(yè)務(wù)結(jié)果
 /// </summary>
 public string result_code { get; set; }
 /// <summary>
 /// 預(yù)支付ID
 /// </summary>
 public string prepay_id { get; set; }
 /// <summary>
 /// 交易類(lèi)型
 /// </summary>
 public string trade_type { get; set; }
 /// <summary>
 /// 二維碼鏈接
 /// </summary>
 public string code_url { get; set; }
 public UnifyReceive(string xml)
 {
  XElement doc = XElement.Parse(xml);
  return_code = doc.Element("return_code").Value;
  return_msg = doc.Element("return_msg").Value;
  if (return_code == "SUCCESS")
  {
  appid = doc.Element("appid").Value;
  mch_id = doc.Element("mch_id").Value;
  nonce_str = doc.Element("nonce_str").Value;
  sign = doc.Element("sign").Value;
  result_code = doc.Element("result_code").Value;
  if (result_code == "SUCCESS")
  {
   trade_type = doc.Element("trade_type").Value;
   prepay_id = doc.Element("prepay_id").Value;
   if (trade_type == "NATIVE")
   {
   code_url = doc.Element("code_url").Value;
   }
   trade_type = doc.Element("trade_type").Value;
  }
  }
 }
 }

TestJs.aspx內(nèi)容:

<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="JsPay.aspx.cs" Inherits="WeChatPayDemo.JsPay" %>

<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
 <title></title>
 <script src="http://code.jquery.com/jquery-1.9.0.js"></script>
 <script src="Scripts/wxpay.js"></script>
 <script>
 $(function () {
  $("#submit").click(function () {
  var OID ="<%=openid%>";
  alert(OID);
  $.get("WxPay/WxPay.ashx?action=jspayparam", {
   body: $("#body").val(),
   total_fee: $("#price").val(),
   out_trade_no: $("#order").val(),
   trade_type: "JSAPI",
   msgid: "<%=openid%>"

  }, function (data) {
   WxPay.Pay(data.appId, data.timeStamp, data.nonceStr, data.package, data.signType, data.paySign, function () {
   alert("支付成功");
   });
  }, "json");

  });
 })
 </script>
</head>
<body>
 <form id="form1" runat="server">
 <p>
  商品描述：<input type="text" id="body" />
  商品價(jià)格：<input type="text" id="price" />
  訂單號(hào)：<input type="text" id="order" />
  <input type="button" value="提交訂單" id="submit" />
 </p>
 </form>
</body>
</html>

JsPay.aspx.cs代碼:

 public partial class JsPay : System.Web.UI.Page
 {
 public string openid = "";
 protected void Page_Load(object sender, EventArgs e)
 {
  string code = Request["code"];
  if (string.IsNullOrEmpty(code))
  {
  //如果code沒(méi)獲取成功，重新拉取一遍
  GetAuthUrl("wxxxxxxxxxxxxxxxxxxxxxxx", "http://www.china101.net/JsPay.aspx");
  }

  openid = GetOpenID("wxxxxxxxxxxxxxxxxxxxxxxx", "dsdssdsdsdsdsdsdsdsdsd", JKRequest.GetQueryString("code"), () => { });
 }
 public string GetOpenID(string appid, string secret, string code, Action CallBack)
 {
  try
  {
  string retdata = Utils.HttpGet(string.Format("https://api.weixin.qq.com/sns/oauth3/access_token?appid={0}&secret={1}&code={2}&grant_type=authorization_code", appid, secret, code));
  .LogHelper.WriteFile(retdata);
  JObject jobj = (JObject)JsonConvert.DeserializeObject(retdata);
  string openid = jobj.Value<string>("openid");
  return openid;
  }
  catch (Exception)
  {
  CallBack();
  return "";
  }
  // return GetUserInfo(access_token, openid);
 }

 /// <summary>
 /// 獲取鑒權(quán)地址
 /// </summary>
 /// <param name="appid"></param>
 /// <param name="redirect_url"></param>
 /// <returns></returns>
 public void GetAuthUrl(string appid, string redirect_url)
 {
  Response.Redirect(string.Format("https://open.weixin.qq.com/connect/oauth3/authorize?appid={0}&redirect_uri={1}&response_type=code&scope=snsapi_base&state=123#wechat_redirect", appid, Utils.UrlEncode(redirect_url)));
 }
 }

WxPay.ashx代碼:

/// <summary>
 /// WxPay 的摘要說(shuō)明
 /// </summary>
 public class WxPay : IHttpHandler
 {
 /// <summary>
 /// 公眾賬號(hào)ID
 /// </summary>
 private string appid = "wxxxxxxxxxxxxxxxx";
 /// <summary>
 /// 商戶(hù)號(hào)
 /// </summary>
 private string mch_id = "12333333333";
 /// <summary>
 /// 通知url
 /// </summary>
 private string notify_url = "http://www.china101.net/Notify2.aspx";
 /// <summary>
 /// 密鑰
 /// </summary>
 private string key = "chinapagexxxxxxxxxxxxx";
 public void ProcessRequest(HttpContext context)
 {
  string action = JKRequest.GetQueryString("action");
  switch (action)
  {
  case "unifysign":
   GetUnifySign(context); break;
  case "jspayparam": GetJsPayParam(context); break;
  case "nativedynamic": GetPayQr(context); break;

  }
 }
 #region 獲取js支付參數(shù)

 void GetJsPayParam(HttpContext context)
 {
  JsEntities jsEntities = new JsEntities()
  {
  appId = appid,
  nonceStr = .Utils.GetRandom(),
  package = string.Format("prepay_id={0}", GetPrepayId(context)),
  signType = "MD5",
  timeStamp = .Utils.ConvertDateTimeInt(DateTime.Now).ToString()
  };
  string url, sign;
  string xmlStr = .Utils.GetUnifyRequestXml<JsEntities>(jsEntities, key, out url, out sign);
  LogHelper.WriteFile(xmlStr);
  jsEntities.paySign = sign;
  context.Response.Write(JsonConvert.SerializeObject(jsEntities));
 }
 #endregion
 #region 獲取預(yù)支付ID


 //--------------------------------------------------------------------------
 string GetPrepayId(HttpContext context)
 {
  string xml;
  GetUnifySign(context, out xml);
  LogHelper.WriteFile("GetPrepayId---71--" + xml);
  UnifyReceive unifyReceive = new UnifyReceive(.Utils.HttpPost("https://api.mch.weixin.qq.com/pay/unifiedorder", xml));
  LogHelper.WriteFile("unifyReceive---73--" + unifyReceive.prepay_id);
  return unifyReceive.prepay_id;
 }
 #endregion
 #region 獲取統(tǒng)一簽名
 void GetUnifySign(HttpContext context)
 {
  string xml;
  context.Response.Write(GetUnifySign(context, out xml));
 }
 #endregion
 #region 獲取統(tǒng)一簽名

 string GetUnifySign(HttpContext context, out string xml)
 {
  string url, sign;
  xml = WxPayHelper.Utils.GetUnifyUrlXml<UnifyEntities>(GetUnifyEntities(context), key, out url, out sign);
  return sign;
 }
 #endregion

 #region 獲取二維碼

 void GetPayQr(HttpContext context)
 {
  string url = GetPayUrl(context);
  WxPayHelper.Utils.GetQrCode(url);
 }
 #endregion
 #region 獲取二維碼鏈接

 string GetPayUrl(HttpContext context)
 {
  string xml;
  GetUnifySign(context, out xml);
  WxPayHelper.Utils.WriteTxt(xml);
  UnifyReceive unifyReceive = new UnifyReceive(WxPayHelper.Utils.HttpPost("https://api.mch.weixin.qq.com/pay/unifiedorder", xml));
  return unifyReceive.code_url;
 }
 #endregion
 #region 獲取統(tǒng)一支付接口參數(shù)對(duì)象

 UnifyEntities GetUnifyEntities(HttpContext context)
 {
  string msgid = JKRequest.GetQueryString("msgid");
  LogHelper.WriteFile("115---------"+msgid);
  UnifyEntities unify = new UnifyEntities
  {
  appid = appid,
  body = JKRequest.GetQueryString("body"),
  mch_id = mch_id,
  nonce_str = WxPayHelper.Utils.GetRandom(),
  out_trade_no = JKRequest.GetQueryString("out_trade_no"),
  notify_url = notify_url,
  spbill_create_ip = JKRequest.GetIP(),
  trade_type = JKRequest.GetQueryString("trade_type"),
  total_fee = JKRequest.GetQueryString("total_fee")
  };
  if (unify.trade_type == "NATIVE")
  {
  unify.product_id = msgid;
  }
  else
  {
  unify.openid = msgid;
  }
  return unify;
 }

 #endregion


 public bool IsReusable
 {
  get
  {
  return false;
  }
 }
 }

Utils.cs代碼:

 public class Utils
 {

 #region MD5加密
 public static string MD5(string pwd)
 {
  MD5 md5 = new MD5CryptoServiceProvider();
  byte[] data = System.Text.Encoding.Default.GetBytes(pwd);
  byte[] md5data = md5.ComputeHash(data);
  md5.Clear();
  string str = "";
  for (int i = 0; i < md5data.Length; i++)
  {
  str += md5data[i].ToString("x").PadLeft(2, '0');

  }
  return str;
 }
 /// <summary>
 /// 獲取文件的md5
 /// </summary>
 /// <param name="filepath">文件路徑，url路徑</param>
 /// <returns>md5字符串</returns>
 string GetMD5HashFromFile(string filepath)
 {
  try
  {
  WebClient wc = new WebClient();

  var file = wc.OpenRead(new Uri(filepath));
  System.Security.Cryptography.MD5 md5 = new System.Security.Cryptography.MD5CryptoServiceProvider();
  byte[] retVal = md5.ComputeHash(file);
  file.Close();

  StringBuilder sb = new StringBuilder();
  for (int i = 0; i < retVal.Length; i++)
  {
   sb.Append(retVal[i].ToString("x2"));
  }
  return sb.ToString();
  }
  catch (Exception ex)
  {
  throw new Exception("GetMD5HashFromFile() fail,error:" + ex.Message);
  }
 }
 #endregion

 #region 對(duì)象轉(zhuǎn)換處理
 /// <summary>
 /// 判斷對(duì)象是否為Int32類(lèi)型的數(shù)字
 /// </summary>
 /// <param name="Expression"></param>
 /// <returns></returns>
 public static bool IsNumeric(object expression)
 {
  if (expression != null)
  return IsNumeric(expression.ToString());

  return false;

 }

 /// <summary>
 /// 判斷對(duì)象是否為Int32類(lèi)型的數(shù)字
 /// </summary>
 /// <param name="Expression"></param>
 /// <returns></returns>
 public static bool IsNumeric(string expression)
 {
  if (expression != null)
  {
  string str = expression;
  if (str.Length > 0 && str.Length <= 11 && Regex.IsMatch(str, @"^[-]?[0-9]*[.]?[0-9]*$"))
  {
   if ((str.Length < 10) || (str.Length == 10 && str[0] == '1') || (str.Length == 11 && str[0] == '-' && str[1] == '1'))
   return true;
  }
  }
  return false;
 }

 /// <summary>
 /// 是否為Double類(lèi)型
 /// </summary>
 /// <param name="expression"></param>
 /// <returns></returns>
 public static bool IsDouble(object expression)
 {
  if (expression != null)
  return Regex.IsMatch(expression.ToString(), @"^([0-9])[0-9]*(\.\w*)?$");

  return false;
 }

 /// <summary>
 /// 檢測(cè)是否符合email格式
 /// </summary>
 /// <param name="strEmail">要判斷的email字符串</param>
 /// <returns>判斷結(jié)果</returns>
 public static bool IsValidEmail(string strEmail)
 {
  return Regex.IsMatch(strEmail, @"^[\w\.]+([-]\w+)*@[A-Za-z0-9-_]+[\.][A-Za-z0-9-_]");
 }
 public static bool IsValidDoEmail(string strEmail)
 {
  return Regex.IsMatch(strEmail, @"^@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.)|(([\w-]+\.)+))([a-zA-Z]{2,4}|[0-9]{1,3})(\]?)$");
 }

 /// <summary>
 /// 檢測(cè)是否是正確的Url
 /// </summary>
 /// <param name="strUrl">要驗(yàn)證的Url</param>
 /// <returns>判斷結(jié)果</returns>
 public static bool IsURL(string strUrl)
 {
  return Regex.IsMatch(strUrl, @"^(http|https)\://([a-zA-Z0-9\.\-]+(\:[a-zA-Z0-9\.&%\$\-]+)*@)*((25[0-5]|2[0-4][0-9]|[0-1]{1}[0-9]{2}|[1-9]{1}[0-9]{1}|[1-9])\.(25[0-5]|2[0-4][0-9]|[0-1]{1}[0-9]{2}|[1-9]{1}[0-9]{1}|[1-9]|0)\.(25[0-5]|2[0-4][0-9]|[0-1]{1}[0-9]{2}|[1-9]{1}[0-9]{1}|[1-9]|0)\.(25[0-5]|2[0-4][0-9]|[0-1]{1}[0-9]{2}|[1-9]{1}[0-9]{1}|[0-9])|localhost|([a-zA-Z0-9\-]+\.)*[a-zA-Z0-9\-]+\.(com|edu|gov|int|mil|net|org|biz|arpa|info|name|pro|aero|coop|museum|[a-zA-Z]{1,10}))(\:[0-9]+)*(/($|[a-zA-Z0-9\.\,\?\'\\\+&%\$#\=~_\-]+))*$");
 }

 /// <summary>
 /// 將字符串轉(zhuǎn)換為數(shù)組
 /// </summary>
 /// <param name="str">字符串</param>
 /// <returns>字符串?dāng)?shù)組</returns>
 public static string[] GetStrArray(string str)
 {
  return str.Split(new char[',']);
 }

 /// <summary>
 /// 將數(shù)組轉(zhuǎn)換為字符串
 /// </summary>
 /// <param name="list">List</param>
 /// <param name="speater">分隔符</param>
 /// <returns>String</returns>
 public static string GetArrayStr(List<string> list, string speater)
 {
  StringBuilder sb = new StringBuilder();
  for (int i = 0; i < list.Count; i++)
  {
  if (i == list.Count - 1)
  {
   sb.Append(list[i]);
  }
  else
  {
   sb.Append(list[i]);
   sb.Append(speater);
  }
  }
  return sb.ToString();
 }

 /// <summary>
 /// object型轉(zhuǎn)換為bool型
 /// </summary>
 /// <param name="strValue">要轉(zhuǎn)換的字符串</param>
 /// <param name="defValue">缺省值</param>
 /// <returns>轉(zhuǎn)換后的bool類(lèi)型結(jié)果</returns>
 public static bool StrToBool(object expression, bool defValue)
 {
  if (expression != null)
  return StrToBool(expression, defValue);

  return defValue;
 }

 /// <summary>
 /// string型轉(zhuǎn)換為bool型
 /// </summary>
 /// <param name="strValue">要轉(zhuǎn)換的字符串</param>
 /// <param name="defValue">缺省值</param>
 /// <returns>轉(zhuǎn)換后的bool類(lèi)型結(jié)果</returns>
 public static bool StrToBool(string expression, bool defValue)
 {
  if (expression != null)
  {
  if (string.Compare(expression, "true", true) == 0)
   return true;
  else if (string.Compare(expression, "false", true) == 0)
   return false;
  }
  return defValue;
 }

 /// <summary>
 /// 將對(duì)象轉(zhuǎn)換為Int32類(lèi)型
 /// </summary>
 /// <param name="expression">要轉(zhuǎn)換的字符串</param>
 /// <param name="defValue">缺省值</param>
 /// <returns>轉(zhuǎn)換后的int類(lèi)型結(jié)果</returns>
 public static int ObjToInt(object expression, int defValue)
 {
  if (expression != null)
  return StrToInt(expression.ToString(), defValue);

  return defValue;
 }

 /// <summary>
 /// 將字符串轉(zhuǎn)換為Int32類(lèi)型
 /// </summary>
 /// <param name="expression">要轉(zhuǎn)換的字符串</param>
 /// <param name="defValue">缺省值</param>
 /// <returns>轉(zhuǎn)換后的int類(lèi)型結(jié)果</returns>
 public static int StrToInt(string expression, int defValue)
 {
  if (string.IsNullOrEmpty(expression) || expression.Trim().Length >= 11 || !Regex.IsMatch(expression.Trim(), @"^([-]|[0-9])[0-9]*(\.\w*)?$"))
  return defValue;

  int rv;
  if (Int32.TryParse(expression, out rv))
  return rv;

  return Convert.ToInt32(StrToFloat(expression, defValue));
 }

 /// <summary>
 /// Object型轉(zhuǎn)換為decimal型
 /// </summary>
 /// <param name="strValue">要轉(zhuǎn)換的字符串</param>
 /// <param name="defValue">缺省值</param>
 /// <returns>轉(zhuǎn)換后的decimal類(lèi)型結(jié)果</returns>
 public static decimal ObjToDecimal(object expression, decimal defValue)
 {
  if (expression != null)
  return StrToDecimal(expression.ToString(), defValue);

  return defValue;
 }

 /// <summary>
 /// string型轉(zhuǎn)換為decimal型
 /// </summary>
 /// <param name="strValue">要轉(zhuǎn)換的字符串</param>
 /// <param name="defValue">缺省值</param>
 /// <returns>轉(zhuǎn)換后的decimal類(lèi)型結(jié)果</returns>
 public static decimal StrToDecimal(string expression, decimal defValue)
 {
  if ((expression == null) || (expression.Length > 10))
  return defValue;

  decimal intValue = defValue;
  if (expression != null)
  {
  bool IsDecimal = Regex.IsMatch(expression, @"^([-]|[0-9])[0-9]*(\.\w*)?$");
  if (IsDecimal)
   decimal.TryParse(expression, out intValue);
  }
  return intValue;
 }

 /// <summary>
 /// Object型轉(zhuǎn)換為float型
 /// </summary>
 /// <param name="strValue">要轉(zhuǎn)換的字符串</param>
 /// <param name="defValue">缺省值</param>
 /// <returns>轉(zhuǎn)換后的int類(lèi)型結(jié)果</returns>
 public static float ObjToFloat(object expression, float defValue)
 {
  if (expression != null)
  return StrToFloat(expression.ToString(), defValue);

  return defValue;
 }

 /// <summary>
 /// string型轉(zhuǎn)換為float型
 /// </summary>
 /// <param name="strValue">要轉(zhuǎn)換的字符串</param>
 /// <param name="defValue">缺省值</param>
 /// <returns>轉(zhuǎn)換后的int類(lèi)型結(jié)果</returns>
 public static float StrToFloat(string expression, float defValue)
 {
  if ((expression == null) || (expression.Length > 10))
  return defValue;

  float intValue = defValue;
  if (expression != null)
  {
  bool IsFloat = Regex.IsMatch(expression, @"^([-]|[0-9])[0-9]*(\.\w*)?$");
  if (IsFloat)
   float.TryParse(expression, out intValue);
  }
  return intValue;
 }

 /// <summary>
 /// 將對(duì)象轉(zhuǎn)換為日期時(shí)間類(lèi)型
 /// </summary>
 /// <param name="str">要轉(zhuǎn)換的字符串</param>
 /// <param name="defValue">缺省值</param>
 /// <returns>轉(zhuǎn)換后的int類(lèi)型結(jié)果</returns>
 public static DateTime StrToDateTime(string str, DateTime defValue)
 {
  if (!string.IsNullOrEmpty(str))
  {
  DateTime dateTime;
  if (DateTime.TryParse(str, out dateTime))
   return dateTime;
  }
  return defValue;
 }

 /// <summary>
 /// 將對(duì)象轉(zhuǎn)換為日期時(shí)間類(lèi)型
 /// </summary>
 /// <param name="str">要轉(zhuǎn)換的字符串</param>
 /// <returns>轉(zhuǎn)換后的int類(lèi)型結(jié)果</returns>
 public static DateTime StrToDateTime(string str)
 {
  return StrToDateTime(str, DateTime.Now);
 }

 /// <summary>
 /// 將對(duì)象轉(zhuǎn)換為日期時(shí)間類(lèi)型
 /// </summary>
 /// <param name="obj">要轉(zhuǎn)換的對(duì)象</param>
 /// <returns>轉(zhuǎn)換后的int類(lèi)型結(jié)果</returns>
 public static DateTime ObjectToDateTime(object obj)
 {
  return StrToDateTime(obj.ToString());
 }

 /// <summary>
 /// 將對(duì)象轉(zhuǎn)換為日期時(shí)間類(lèi)型
 /// </summary>
 /// <param name="obj">要轉(zhuǎn)換的對(duì)象</param>
 /// <param name="defValue">缺省值</param>
 /// <returns>轉(zhuǎn)換后的int類(lèi)型結(jié)果</returns>
 public static DateTime ObjectToDateTime(object obj, DateTime defValue)
 {
  return StrToDateTime(obj.ToString(), defValue);
 }

 /// <summary>
 /// 將對(duì)象轉(zhuǎn)換為字符串
 /// </summary>
 /// <param name="obj">要轉(zhuǎn)換的對(duì)象</param>
 /// <returns>轉(zhuǎn)換后的string類(lèi)型結(jié)果</returns>
 public static string ObjectToStr(object obj)
 {
  if (obj == null)
  return "";
  return obj.ToString().Trim();
 }

 /// <summary>
 /// 判斷是否郵箱
 /// </summary>
 /// <param name="expression"></param>
 /// <returns></returns>
 public static bool IsEmail(string expression)
 {
  return Regex.IsMatch(expression, @"^([\w-\.]+)@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.)|(([\w-]+\.)+))([a-zA-Z]{2,4}|[0-9]{1,3})(\]?)$");
 }

 /// <summary>
 /// 判斷是否手機(jī)
 /// </summary>
 /// <param name="expression"></param>
 /// <returns></returns>
 public static bool IsMobile(string expression)
 {
  return Regex.IsMatch(expression, @"^1[3|4|5|6|7|8|9][0-9]{9}$");
 }

 public static bool IsPhone(string telphone)
 {
  Regex regex = new Regex(@"^(\d{3,4}-)?\d{6,8}$");
  return regex.IsMatch(telphone);
 }
 #endregion

 #region 分割字符串
 /// <summary>
 /// 分割字符串
 /// </summary>
 public static string[] SplitString(string strContent, string strSplit)
 {
  if (!string.IsNullOrEmpty(strContent))
  {
  if (strContent.IndexOf(strSplit) < 0)
   return new string[] { strContent };

  return Regex.Split(strContent, Regex.Escape(strSplit), RegexOptions.IgnoreCase);
  }
  else
  return new string[0] { };
 }

 /// <summary>
 /// 分割字符串
 /// </summary>
 /// <returns></returns>
 public static string[] SplitString(string strContent, string strSplit, int count)
 {
  string[] result = new string[count];
  string[] splited = SplitString(strContent, strSplit);

  for (int i = 0; i < count; i++)
  {
  if (i < splited.Length)
   result[i] = splited[i];
  else
   result[i] = string.Empty;
  }

  return result;
 }
 #endregion

 #region 刪除最后結(jié)尾的一個(gè)逗號(hào)
 /// <summary>
 /// 刪除最后結(jié)尾的一個(gè)逗號(hào)
 /// </summary>
 public static string DelLastComma(string str)
 {
  if (str.Length < 1)
  {
  return "";
  }
  return str.Substring(0, str.LastIndexOf(","));
 }
 #endregion

 #region 刪除最后結(jié)尾的指定字符后的字符
 /// <summary>
 /// 刪除最后結(jié)尾的指定字符后的字符
 /// </summary>
 public static string DelLastChar(string str, string strchar)
 {
  if (string.IsNullOrEmpty(str))
  return "";
  if (str.LastIndexOf(strchar) >= 0 && str.LastIndexOf(strchar) == str.Length - 1)
  {
  return str.Substring(0, str.LastIndexOf(strchar));
  }
  return str;
 }
 #endregion

 #region 生成指定長(zhǎng)度的字符串
 /// <summary>
 /// 生成指定長(zhǎng)度的字符串,即生成strLong個(gè)str字符串
 /// </summary>
 /// <param name="strLong">生成的長(zhǎng)度</param>
 /// <param name="str">以str生成字符串</param>
 /// <returns></returns>
 public static string StringOfChar(int strLong, string str)
 {
  string ReturnStr = "";
  for (int i = 0; i < strLong; i++)
  {
  ReturnStr += str;
  }

  return ReturnStr;
 }
 #endregion

 #region 生成日期隨機(jī)碼
 /// <summary>
 /// 生成日期隨機(jī)碼
 /// </summary>
 /// <returns></returns>
 public static string GetRamCode()
 {
  #region
  return DateTime.Now.ToString("yyyyMMddHHmmssffff");
  #endregion
 }
 #endregion

 #region 生成隨機(jī)字母或數(shù)字
 /// <summary>
 /// 生成隨機(jī)數(shù)字
 /// </summary>
 /// <param name="length">生成長(zhǎng)度</param>
 /// <returns></returns>
 public static string Number(int Length)
 {
  return Number(Length, false);
 }

 /// <summary>
 /// 生成隨機(jī)數(shù)字
 /// </summary>
 /// <param name="Length">生成長(zhǎng)度</param>
 /// <param name="Sleep">是否要在生成前將當(dāng)前線程阻止以避免重復(fù)</param>
 /// <returns></returns>
 public static string Number(int Length, bool Sleep)
 {
  if (Sleep)
  System.Threading.Thread.Sleep(3);
  string result = "";
  System.Random random = new Random();
  for (int i = 0; i < Length; i++)
  {
  result += random.Next(10).ToString();
  }
  return result;
 }
 /// <summary>
 /// 生成隨機(jī)字母字符串(數(shù)字字母混和)
 /// </summary>
 /// <param name="codeCount">待生成的位數(shù)</param>
 public static string GetCheckCode(int codeCount)
 {
  string str = string.Empty;
  int rep = 0;
  long num2 = DateTime.Now.Ticks + rep;
  rep++;
  Random random = new Random(((int)(((ulong)num2) & 0xffffffffL)) | ((int)(num2 >> rep)));
  for (int i = 0; i < codeCount; i++)
  {
  char ch;
  int num = random.Next();
  if ((num % 2) == 0)
  {
   ch = (char)(0x30 + ((ushort)(num % 10)));
  }
  else
  {
   ch = (char)(0x41 + ((ushort)(num % 0x1a)));
  }
  str = str + ch.ToString();
  }
  return str;
 }
 /// <summary>
 /// 根據(jù)日期和隨機(jī)碼生成訂單號(hào)
 /// </summary>
 /// <returns></returns>
 public static string GetOrderNumber()
 {
  string num = DateTime.Now.ToString("yyMMddHHmmss");//yyyyMMddHHmmssms
  return num + Number(2).ToString();
 }
 private static int Next(int numSeeds, int length)
 {
  byte[] buffer = new byte[length];
  System.Security.Cryptography.RNGCryptoServiceProvider Gen = new System.Security.Cryptography.RNGCryptoServiceProvider();
  Gen.GetBytes(buffer);
  uint randomResult = 0x0;//這里用uint作為生成的隨機(jī)數(shù) 
  for (int i = 0; i < length; i++)
  {
  randomResult |= ((uint)buffer[i] << ((length - 1 - i) * 8));
  }
  return (int)(randomResult % numSeeds);
 }
 #endregion

 #region 截取字符長(zhǎng)度
 /// <summary>
 /// 截取字符長(zhǎng)度
 /// </summary>
 /// <param name="inputString">字符</param>
 /// <param name="len">長(zhǎng)度</param>
 /// <returns></returns>
 public static string CutString(string inputString, int len)
 {
  if (string.IsNullOrEmpty(inputString))
  return "";
  inputString = DropHTML(inputString);
  ASCIIEncoding ascii = new ASCIIEncoding();
  int tempLen = 0;
  string tempString = "";
  byte[] s = ascii.GetBytes(inputString);
  for (int i = 0; i < s.Length; i++)
  {
  if ((int)s[i] == 63)
  {
   tempLen += 2;
  }
  else
  {
   tempLen += 1;
  }

  try
  {
   tempString += inputString.Substring(i, 1);
  }
  catch
  {
   break;
  }

  if (tempLen > len)
   break;
  }
  //如果截過(guò)則加上半個(gè)省略號(hào) 
  byte[] mybyte = System.Text.Encoding.Default.GetBytes(inputString);
  if (mybyte.Length > len)
  tempString += "…";
  return tempString;
 }
 #endregion

 #region 清除HTML標(biāo)記
 public static string DropHTML(string Htmlstring)
 {
  if (string.IsNullOrEmpty(Htmlstring)) return "";
  //刪除腳本 
  Htmlstring = Regex.Replace(Htmlstring, @"<script[^>]*?>.*?</script>", "", RegexOptions.IgnoreCase);
  //刪除HTML 
  Htmlstring = Regex.Replace(Htmlstring, @"<(.[^>]*)>", "", RegexOptions.IgnoreCase);
  Htmlstring = Regex.Replace(Htmlstring, @"([\r\n])[\s]+", "", RegexOptions.IgnoreCase);
  Htmlstring = Regex.Replace(Htmlstring, @"-->", "", RegexOptions.IgnoreCase);
  Htmlstring = Regex.Replace(Htmlstring, @"<!--.*", "", RegexOptions.IgnoreCase);
  Htmlstring = Regex.Replace(Htmlstring, @"&(quot|#34);", "\"", RegexOptions.IgnoreCase);
  Htmlstring = Regex.Replace(Htmlstring, @"&(amp|#38);", "&", RegexOptions.IgnoreCase);
  Htmlstring = Regex.Replace(Htmlstring, @"&(lt|#60);", "<", RegexOptions.IgnoreCase);
  Htmlstring = Regex.Replace(Htmlstring, @"&(gt|#62);", ">", RegexOptions.IgnoreCase);
  Htmlstring = Regex.Replace(Htmlstring, @"&(nbsp|#160);", " ", RegexOptions.IgnoreCase);
  Htmlstring = Regex.Replace(Htmlstring, @"&(iexcl|#161);", "\xa1", RegexOptions.IgnoreCase);
  Htmlstring = Regex.Replace(Htmlstring, @"&(cent|#162);", "\xa2", RegexOptions.IgnoreCase);
  Htmlstring = Regex.Replace(Htmlstring, @"&(pound|#163);", "\xa3", RegexOptions.IgnoreCase);
  Htmlstring = Regex.Replace(Htmlstring, @"&(copy|#169);", "\xa9", RegexOptions.IgnoreCase);

  Htmlstring = Regex.Replace(Htmlstring, @"(\d+);", "", RegexOptions.IgnoreCase);
  Htmlstring.Replace("<", "");
  Htmlstring.Replace(">", "");
  Htmlstring.Replace("\r\n", "");
  Htmlstring = HttpContext.Current.Server.HtmlEncode(Htmlstring).Trim();
  return Htmlstring;
 }
 #endregion

 #region 清除HTML標(biāo)記且返回相應(yīng)的長(zhǎng)度
 public static string DropHTML(string Htmlstring, int strLen)
 {
  return CutString(DropHTML(Htmlstring), strLen);
 }
 #endregion

 #region TXT代碼轉(zhuǎn)換成HTML格式
 /// <summary>
 /// 字符串字符處理
 /// </summary>
 /// <param name="chr">等待處理的字符串</param>
 /// <returns>處理后的字符串</returns>
 /// //把TXT代碼轉(zhuǎn)換成HTML格式
 public static String ToHtml(string Input)
 {
  StringBuilder sb = new StringBuilder(Input);
  sb.Replace("&", "&");
  sb.Replace("<", "<");
  sb.Replace(">", ">");
  sb.Replace("\r\n", "<br />");
  sb.Replace("\n", "<br />");
  sb.Replace("\t", " ");
  //sb.Replace(" ", " ");
  return sb.ToString();
 }
 #endregion

 #region HTML代碼轉(zhuǎn)換成TXT格式
 /// <summary>
 /// 字符串字符處理
 /// </summary>
 /// <param name="chr">等待處理的字符串</param>
 /// <returns>處理后的字符串</returns>
 /// //把HTML代碼轉(zhuǎn)換成TXT格式
 public static String ToTxt(String Input)
 {
  StringBuilder sb = new StringBuilder(Input);
  sb.Replace(" ", " ");
  sb.Replace("<br>", "\r\n");
  sb.Replace("<br>", "\n");
  sb.Replace("<br />", "\n");
  sb.Replace("<br />", "\r\n");
  sb.Replace("<", "<");
  sb.Replace(">", ">");
  sb.Replace("&", "&");
  return sb.ToString();
 }
 #endregion

 #region 檢測(cè)是否有Sql危險(xiǎn)字符
 /// <summary>
 /// 檢測(cè)是否有Sql危險(xiǎn)字符
 /// </summary>
 /// <param name="str">要判斷字符串</param>
 /// <returns>判斷結(jié)果</returns>
 public static bool IsSafeSqlString(string str)
 {
  return !Regex.IsMatch(str, @"[-|;|,|\/|\(|\)|\[|\]|\}|\{|%|@|\*|!|\']");
 }

 /// <summary>
 /// 檢查危險(xiǎn)字符
 /// </summary>
 /// <param name="Input"></param>
 /// <returns></returns>
 public static string Filter(string sInput)
 {
  if (sInput == null || sInput == "")
  return null;
  string sInput1 = sInput.ToLower();
  string output = sInput;
  string pattern = @"*|and|exec|insert|select|delete|update|count|master|truncate|declare|char(|mid(|chr(|'";
  if (Regex.Match(sInput1, Regex.Escape(pattern), RegexOptions.Compiled | RegexOptions.IgnoreCase).Success)
  {
  throw new Exception("字符串中含有非法字符!");
  }
  else
  {
  output = output.Replace("'", "''");
  }
  return output;
 }

 /// <summary> 
 /// 檢查過(guò)濾設(shè)定的危險(xiǎn)字符
 /// </summary> 
 /// <param name="InText">要過(guò)濾的字符串 </param> 
 /// <returns>如果參數(shù)存在不安全字符，則返回true </returns> 
 public static bool SqlFilter(string word, string InText)
 {
  if (InText == null)
  return false;
  foreach (string i in word.Split('|'))
  {
  if ((InText.ToLower().IndexOf(i + " ") > -1) || (InText.ToLower().IndexOf(" " + i) > -1))
  {
   return true;
  }
  }
  return false;
 }
 #endregion

 #region 過(guò)濾特殊字符
 /// <summary>
 /// 過(guò)濾特殊字符
 /// </summary>
 /// <param name="Input"></param>
 /// <returns></returns>
 public static string Htmls(string Input)
 {
  if (Input != string.Empty && Input != null)
  {
  string ihtml = Input.ToLower();
  ihtml = ihtml.Replace("<script", "<script");
  ihtml = ihtml.Replace("script>", "script>");
  ihtml = ihtml.Replace("<%", "<%");
  ihtml = ihtml.Replace("%>", "%>");
  ihtml = ihtml.Replace("<$", "<$");
  ihtml = ihtml.Replace("$>", "$>");
  return ihtml;
  }
  else
  {
  return string.Empty;
  }
 }
 #endregion

 #region 檢查是否為IP地址
 /// <summary>
 /// 是否為ip
 /// </summary>
 /// <param name="ip"></param>
 /// <returns></returns>
 public static bool IsIP(string ip)
 {
  return Regex.IsMatch(ip, @"^((2[0-4]\d|25[0-5]|[01]?\d\d?)\.){3}(2[0-4]\d|25[0-5]|[01]?\d\d?)$");
 }
 #endregion

 #region 獲得配置文件節(jié)點(diǎn)XML文件的絕對(duì)路徑
 public static string GetXmlMapPath(string xmlName)
 {
  return GetMapPath(ConfigurationManager.AppSettings[xmlName].ToString());
 }
 #endregion

 #region 獲得當(dāng)前絕對(duì)路徑
 /// <summary>
 /// 獲得當(dāng)前絕對(duì)路徑
 /// </summary>
 /// <param name="strPath">指定的路徑</param>
 /// <returns>絕對(duì)路徑</returns>
 public static string GetMapPath(string strPath)
 {
  if (strPath.ToLower().StartsWith("http://"))
  {
  return strPath;
  }
  if (HttpContext.Current != null)
  {
  return HttpContext.Current.Server.MapPath(strPath);
  }
  else //非web程序引用
  {
  strPath = strPath.Replace("/", "\\");
  if (strPath.StartsWith("\\"))
  {
   strPath = strPath.Substring(strPath.IndexOf('\\', 1)).TrimStart('\\');
  }
  return System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, strPath);
  }
 }
 #endregion

 #region 文件操作
 /// <summary>
 /// 刪除單個(gè)文件
 /// </summary>
 /// <param name="_filepath">文件相對(duì)路徑</param>
 public static bool DeleteFile(string _filepath)
 {
  if (string.IsNullOrEmpty(_filepath))
  {
  return false;
  }
  string fullpath = GetMapPath(_filepath);
  if (File.Exists(fullpath))
  {
  File.Delete(fullpath);
  return true;
  }
  return false;
 }

 /// <summary>
 /// 刪除上傳的文件(及縮略圖)
 /// </summary>
 /// <param name="_filepath"></param>
 public static void DeleteUpFile(string _filepath)
 {
  if (string.IsNullOrEmpty(_filepath))
  {
  return;
  }
  string fullpath = GetMapPath(_filepath); //原圖
  if (File.Exists(fullpath))
  {
  File.Delete(fullpath);
  }
  if (_filepath.LastIndexOf("/") >= 0)
  {
  string thumbnailpath = _filepath.Substring(0, _filepath.LastIndexOf("/")) + "mall_" + _filepath.Substring(_filepath.LastIndexOf("/") + 1);
  string fullTPATH = GetMapPath(thumbnailpath); //宿略圖
  if (File.Exists(fullTPATH))
  {
   File.Delete(fullTPATH);
  }
  }
 }

 /// <summary>
 /// 刪除指定文件夾
 /// </summary>
 /// <param name="_dirpath">文件相對(duì)路徑</param>
 public static bool DeleteDirectory(string _dirpath)
 {
  if (string.IsNullOrEmpty(_dirpath))
  {
  return false;
  }
  string fullpath = GetMapPath(_dirpath);
  if (Directory.Exists(fullpath))
  {
  Directory.Delete(fullpath, true);
  return true;
  }
  return false;
 }

 /// <summary>
 /// 修改指定文件夾名稱(chēng)
 /// </summary>
 /// <param name="old_dirpath">舊相對(duì)路徑</param>
 /// <param name="new_dirpath">新相對(duì)路徑</param>
 /// <returns>bool</returns>
 public static bool MoveDirectory(string old_dirpath, string new_dirpath)
 {
  if (string.IsNullOrEmpty(old_dirpath))
  {
  return false;
  }
  string fulloldpath = GetMapPath(old_dirpath);
  string fullnewpath = GetMapPath(new_dirpath);
  if (Directory.Exists(fulloldpath))
  {
  Directory.Move(fulloldpath, fullnewpath);
  return true;
  }
  return false;
 }

 /// <summary>
 /// 返回文件大小KB
 /// </summary>
 /// <param name="_filepath">文件相對(duì)路徑</param>
 /// <returns>int</returns>
 public static int GetFileSize(string _filepath)
 {
  if (string.IsNullOrEmpty(_filepath))
  {
  return 0;
  }
  string fullpath = GetMapPath(_filepath);
  if (File.Exists(fullpath))
  {
  FileInfo fileInfo = new FileInfo(fullpath);
  return ((int)fileInfo.Length) / 1024;
  }
  return 0;
 }

 /// <summary>
 /// 返回文件擴(kuò)展名，不含“.”
 /// </summary>
 /// <param name="_filepath">文件全名稱(chēng)</param>
 /// <returns>string</returns>
 public static string GetFileExt(string _filepath)
 {
  if (string.IsNullOrEmpty(_filepath))
  {
  return "";
  }
  if (_filepath.LastIndexOf(".") > 0)
  {
  return _filepath.Substring(_filepath.LastIndexOf(".") + 1); //文件擴(kuò)展名，不含“.”
  }
  return "";
 }

 /// <summary>
 /// 返回文件名，不含路徑
 /// </summary>
 /// <param name="_filepath">文件相對(duì)路徑</param>
 /// <returns>string</returns>
 public static string GetFileName(string _filepath)
 {
  return _filepath.Substring(_filepath.LastIndexOf(@"/") + 1);
 }

 /// <summary>
 /// 文件是否存在
 /// </summary>
 /// <param name="_filepath">文件相對(duì)路徑</param>
 /// <returns>bool</returns>
 public static bool FileExists(string _filepath)
 {
  string fullpath = GetMapPath(_filepath);
  if (File.Exists(fullpath))
  {
  return true;
  }
  return false;
 }
 #endregion

 #region 讀取或?qū)懭隿ookie
 /// <summary>
 /// 寫(xiě)cookie值
 /// </summary>
 /// <param name="strName">名稱(chēng)</param>
 /// <param name="strValue">值</param>
 public static void WriteCookie(string strName, string strValue)
 {
  HttpCookie cookie = HttpContext.Current.Request.Cookies[strName];
  if (cookie == null)
  {
  cookie = new HttpCookie(strName);
  }
  cookie.Value = UrlEncode(strValue);
  HttpContext.Current.Response.AppendCookie(cookie);
 }

 /// <summary>
 /// 寫(xiě)cookie值
 /// </summary>
 /// <param name="strName">名稱(chēng)</param>
 /// <param name="strValue">值</param>
 public static void WriteCookie(string strName, string key, string strValue)
 {
  HttpCookie cookie = HttpContext.Current.Request.Cookies[strName];
  if (cookie == null)
  {
  cookie = new HttpCookie(strName);
  }
  cookie[key] = UrlEncode(strValue);
  HttpContext.Current.Response.AppendCookie(cookie);
 }

 /// <summary>
 /// 寫(xiě)cookie值
 /// </summary>
 /// <param name="strName">名稱(chēng)</param>
 /// <param name="strValue">值</param>
 public static void WriteCookie(string strName, string key, string strValue, int expires)
 {
  HttpCookie cookie = HttpContext.Current.Request.Cookies[strName];
  if (cookie == null)
  {
  cookie = new HttpCookie(strName);
  }
  cookie[key] = UrlEncode(strValue);
  cookie.Expires = DateTime.Now.AddMinutes(expires);
  HttpContext.Current.Response.AppendCookie(cookie);
 }

 /// <summary>
 /// 寫(xiě)cookie值
 /// </summary>
 /// <param name="strName">名稱(chēng)</param>
 /// <param name="strValue">值</param>
 /// <param name="strValue">過(guò)期時(shí)間(分鐘)</param>
 public static void WriteCookie(string strName, string strValue, int expires)
 {
  HttpCookie cookie = HttpContext.Current.Request.Cookies[strName];
  if (cookie == null)
  {
  cookie = new HttpCookie(strName);
  }
  cookie.Value = UrlEncode(strValue);
  cookie.Expires = DateTime.Now.AddMinutes(expires);
  HttpContext.Current.Response.AppendCookie(cookie);
 }

 /// <summary>
 /// 讀cookie值
 /// </summary>
 /// <param name="strName">名稱(chēng)</param>
 /// <returns>cookie值</returns>
 public static string GetCookie(string strName)
 {
  if (HttpContext.Current.Request.Cookies != null && HttpContext.Current.Request.Cookies[strName] != null)
  return UrlDecode(HttpContext.Current.Request.Cookies[strName].Value.ToString());
  return "";
 }

 /// <summary>
 /// 讀cookie值
 /// </summary>
 /// <param name="strName">名稱(chēng)</param>
 /// <returns>cookie值</returns>
 public static string GetCookie(string strName, string key)
 {
  if (HttpContext.Current.Request.Cookies != null && HttpContext.Current.Request.Cookies[strName] != null && HttpContext.Current.Request.Cookies[strName][key] != null)
  return UrlDecode(HttpContext.Current.Request.Cookies[strName][key].ToString());

  return "";
 }

 public static void ClearCookie(string strName)
 {
  HttpCookie cookie = new HttpCookie(strName);
  cookie.Values.Clear();
  cookie.Expires = DateTime.Now.AddYears(-1);
  HttpContext.Current.Response.AppendCookie(cookie);
 }

 public static void ClearCookie(string strName, string cookiedomain)
 {
  HttpCookie cookie = new HttpCookie(strName);
  cookie.Values.Clear();
  cookie.Expires = DateTime.Now.AddYears(-1);
  string text = cookiedomain;
  if (((text != string.Empty) && (HttpContext.Current.Request.Url.Host.IndexOf(text) > -1)) && IsValidDomain(HttpContext.Current.Request.Url.Host))
  {
  cookie.Domain = text;
  }
  HttpContext.Current.Response.AppendCookie(cookie);
 }

 public static bool IsValidDomain(string host)
 {
  Regex regex = new Regex(@"^\d+$");
  if (host.IndexOf(".") == -1)
  {
  return false;
  }
  return !regex.IsMatch(host.Replace(".", string.Empty));
 }
 #endregion

 #region 替換指定的字符串
 /// <summary>
 /// 替換指定的字符串
 /// </summary>
 /// <param name="originalStr">原字符串</param>
 /// <param name="oldStr">舊字符串</param>
 /// <param name="newStr">新字符串</param>
 /// <returns></returns>
 public static string ReplaceStr(string originalStr, string oldStr, string newStr)
 {
  if (string.IsNullOrEmpty(oldStr))
  {
  return "";
  }
  return originalStr.Replace(oldStr, newStr);
 }
 #endregion

 #region 顯示分頁(yè)
 /// <summary>
 /// 返回分頁(yè)頁(yè)碼
 /// </summary>
 /// <param name="pageSize">頁(yè)面大小</param>
 /// <param name="pageIndex">當(dāng)前頁(yè)</param>
 /// <param name="totalCount">總記錄數(shù)</param>
 /// <param name="linkUrl">鏈接地址，__id__代表頁(yè)碼</param>
 /// <param name="centSize">中間頁(yè)碼數(shù)量</param>
 /// <returns></returns>
 public static string OutPageList(int pageSize, int pageIndex, int totalCount, string linkUrl, int centSize)
 {
  //計(jì)算頁(yè)數(shù)
  if (totalCount < 1 || pageSize < 1)
  {
  return "";
  }
  int pageCount = totalCount / pageSize;
  if (pageCount < 1)
  {
  return "";
  }
  if (totalCount % pageSize > 0)
  {
  pageCount += 1;
  }
  if (pageCount <= 1)
  {
  return "";
  }
  StringBuilder pageStr = new StringBuilder();
  string pageId = "__id__";
  string firstBtn = "<a href=\"" + ReplaceStr(linkUrl, pageId, (pageIndex - 1).ToString()) + "\"><</a>";
  string lastBtn = "<a href=\"" + ReplaceStr(linkUrl, pageId, (pageIndex + 1).ToString()) + "\">></a>";
  string firstStr = "<a href=\"" + ReplaceStr(linkUrl, pageId, "1") + "\">1</a>";
  string lastStr = "<a href=\"" + ReplaceStr(linkUrl, pageId, pageCount.ToString()) + "\">" + pageCount.ToString() + "</a>";

  if (pageIndex <= 1)
  {
  firstBtn = "<a href=\"#_\"><</a>";
  }
  if (pageIndex >= pageCount)
  {
  lastBtn = "<a href=\"#_\">></a>";
  }
  if (pageIndex == 1)
  {
  firstStr = "<a href=\"#_\" class=\"select\">1</a>";
  }
  if (pageIndex == pageCount)
  {
  lastStr = "<a href=\"#_\" class=\"select\">" + pageCount.ToString() + "</a>";
  }
  int firstNum = pageIndex - (centSize / 2); //中間開(kāi)始的頁(yè)碼
  if (pageIndex < centSize)
  firstNum = 2;
  int lastNum = pageIndex + centSize - ((centSize / 2) + 1); //中間結(jié)束的頁(yè)碼
  if (lastNum >= pageCount)
  lastNum = pageCount - 1;
  pageStr.Append(firstBtn + firstStr);
  if (pageIndex >= centSize)
  {
  pageStr.Append("<span>...</span>\n");
  }
  for (int i = firstNum; i <= lastNum; i++)
  {
  if (i == pageIndex)
  {
   pageStr.Append("<a href=\"#_\" class=\"select\">" + i + "</a>");
  }
  else
  {
   pageStr.Append("<a href=\"" + ReplaceStr(linkUrl, pageId, i.ToString()) + "\">" + i + "</a>");
  }
  }
  if (pageCount - pageIndex > centSize - ((centSize / 2)))
  {
  pageStr.Append("<span>...</span>");
  }
  pageStr.Append(lastStr + lastBtn);
  return pageStr.ToString();
 }
 #endregion

 #region ajax顯示分頁(yè)
 /// <summary>
 /// 返回分頁(yè)頁(yè)碼
 /// </summary>
 /// <param name="pageSize">頁(yè)面大小</param>
 /// <param name="pageIndex">當(dāng)前頁(yè)</param>
 /// <param name="totalCount">總記錄數(shù)</param>
 /// <param name="linkUrl">鏈接地址，__id__代表頁(yè)碼</param>
 /// <param name="centSize">中間頁(yè)碼數(shù)量</param>
 /// <returns></returns>
 public static string OutPageListAjax(int pageSize, int pageIndex, int totalCount, int centSize)
 {
  //計(jì)算頁(yè)數(shù)
  if (totalCount < 1 || pageSize < 1)
  {
  return "";
  }
  int pageCount = totalCount / pageSize;
  if (pageCount < 1)
  {
  return "";
  }
  if (totalCount % pageSize > 0)
  {
  pageCount += 1;
  }
  if (pageCount <= 1)
  {
  return "";
  }
  StringBuilder pageStr = new StringBuilder();
  string firstBtn = "<a data-id=\"" + (pageIndex - 1).ToString() + "\" href=\"#_\"><</a>";
  string lastBtn = "<a data-id=\"" + (pageIndex + 1).ToString() + "\" href=\"#_\">></a>";
  string firstStr = "<a data-id=\"1\" href=\"#_\">1</a>";
  string lastStr = "<a data-id=\"" + pageCount.ToString() + "\" href=\"#_\">" + pageCount.ToString() + "</a>";

  if (pageIndex <= 1)
  {
  firstBtn = "<a href=\"#_\"><</a>";
  }
  if (pageIndex >= pageCount)
  {
  lastBtn = "<a href=\"#_\">></a>";
  }
  if (pageIndex == 1)
  {
  firstStr = "<a href=\"#_\" class=\"select\">1</a>";
  }
  if (pageIndex == pageCount)
  {
  lastStr = "<a href=\"#_\" class=\"select\">" + pageCount.ToString() + "</a>";
  }
  int firstNum = pageIndex - (centSize / 2); //中間開(kāi)始的頁(yè)碼
  if (pageIndex < centSize)
  firstNum = 2;
  int lastNum = pageIndex + centSize - ((centSize / 2) + 1); //中間結(jié)束的頁(yè)碼
  if (lastNum >= pageCount)
  lastNum = pageCount - 1;
  pageStr.Append(firstBtn + firstStr);
  if (pageIndex >= centSize)
  {
  pageStr.Append("<span>...</span>\n");
  }
  for (int i = firstNum; i <= lastNum; i++)
  {
  if (i == pageIndex)
  {
   pageStr.Append("<a href=\"#_\" class=\"select\">" + i + "</a>");
  }
  else
  {
   pageStr.Append("<a data-id=\"" + i.ToString() + "\" href=\"#_\">" + i + "</a>");
  }
  }
  if (pageCount - pageIndex > centSize - ((centSize / 2)))
  {
  pageStr.Append("<span>...</span>");
  }
  pageStr.Append(lastStr + lastBtn);
  return pageStr.ToString();
 }
 #endregion

 #region URL處理
 /// <summary>
 /// URL字符編碼
 /// </summary>
 public static string UrlEncode(string str)
 {
  if (string.IsNullOrEmpty(str))
  {
  return "";
  }
  str = str.Replace("'", "");
  return HttpContext.Current.Server.UrlEncode(str);
 }

 /// <summary>
 /// URL字符解碼
 /// </summary>
 public static string UrlDecode(string str)
 {
  if (string.IsNullOrEmpty(str))
  {
  return "";
  }
  return HttpContext.Current.Server.UrlDecode(str);
 }

 /// <summary>
 /// 組合URL參數(shù)
 /// </summary>
 /// <param name="_url">頁(yè)面地址</param>
 /// <param name="_keys">參數(shù)名稱(chēng)</param>
 /// <param name="_values">參數(shù)值</param>
 /// <returns>String</returns>
 public static string CombUrlTxt(string _url, string _keys, params string[] _values)
 {
  StringBuilder urlParams = new StringBuilder();
  try
  {
  string[] keyArr = _keys.Split(new char[] { '&' });
  for (int i = 0; i < keyArr.Length; i++)
  {
   if (!string.IsNullOrEmpty(_values[i]) && _values[i] != "0")
   {
   _values[i] = UrlEncode(_values[i]);
   urlParams.Append(string.Format(keyArr[i], _values) + "&");
   }
  }
  if (!string.IsNullOrEmpty(urlParams.ToString()) && _url.IndexOf("?") == -1)
   urlParams.Insert(0, "?");
  }
  catch
  {
  return _url;
  }
  return _url + DelLastChar(urlParams.ToString(), "&");
 }
 #endregion

 #region URL請(qǐng)求數(shù)據(jù)
 /// <summary>
 /// HTTP POST方式請(qǐng)求數(shù)據(jù)
 /// </summary>
 /// <param name="url">URL.</param>
 /// <param name="param">POST的數(shù)據(jù)</param>
 /// <returns></returns>
 public static string HttpPost(string url, string param)
 {
  HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(url);
  request.Method = "POST";
  request.ContentType = "application/x-www-form-urlencoded";
  request.Accept = "*/*";
  request.Timeout = 15000;
  request.AllowAutoRedirect = false;

  StreamWriter requestStream = null;
  WebResponse response = null;
  string responseStr = null;

  try
  {
  requestStream = new StreamWriter(request.GetRequestStream());
  requestStream.Write(param);
  requestStream.Close();

  response = request.GetResponse();
  if (response != null)
  {
   StreamReader reader = new StreamReader(response.GetResponseStream(), Encoding.UTF8);
   responseStr = reader.ReadToEnd();
   reader.Close();
  }
  }
  catch (Exception)
  {
  throw;
  }
  finally
  {
  request = null;
  requestStream = null;
  response = null;
  }

  return responseStr;
 }

 /// <summary>
 /// HTTP GET方式請(qǐng)求數(shù)據(jù).
 /// </summary>
 /// <param name="url">URL.</param>
 /// <returns></returns>
 public static string HttpGet(string url)
 {
  HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(url);
  request.Method = "GET";
  //request.ContentType = "application/x-www-form-urlencoded";
  request.Accept = "*/*";
  request.Timeout = 15000;
  request.AllowAutoRedirect = false;

  WebResponse response = null;
  string responseStr = null;

  try
  {
  response = request.GetResponse();

  if (response != null)
  {
   StreamReader reader = new StreamReader(response.GetResponseStream(), Encoding.UTF8);
   responseStr = reader.ReadToEnd();
   reader.Close();
  }
  }
  catch (Exception)
  {
  throw;
  }
  finally
  {
  request = null;
  response = null;
  }

  return responseStr;
 }
 /// <summary>
 /// 發(fā)起get請(qǐng)求，獲取響應(yīng)流
 /// </summary>
 /// <param name="url"></param>
 /// <returns></returns>
 public static Stream HttpGetToStream(string url)
 {
  try
  {
  HttpWebRequest req = (HttpWebRequest)WebRequest.Create(url);
  req.Method = "GET";
  //request.ContentType = "application/x-www-form-urlencoded";
  req.Accept = "*/*";
  using (HttpWebResponse response = (HttpWebResponse)req.GetResponse())
  {
   if (response != null)
   {
   return response.GetResponseStream();
   }
   return null;
  }
  }
  catch (Exception)
  {

  return null;
  }

 }
 /// <summary>
 /// 執(zhí)行URL獲取頁(yè)面內(nèi)容
 /// </summary>
 public static string UrlExecute(string urlPath)
 {
  if (string.IsNullOrEmpty(urlPath))
  {
  return "error";
  }
  StringWriter sw = new StringWriter();
  try
  {
  HttpContext.Current.Server.Execute(urlPath, sw);
  return sw.ToString();
  }
  catch (Exception)
  {
  return "error";
  }
  finally
  {
  sw.Close();
  sw.Dispose();
  }
 }
 #endregion

 #region 操作權(quán)限菜單
 /// <summary>
 /// 獲取操作權(quán)限
 /// </summary>
 /// <returns>Dictionary</returns>
 public static Dictionary<string, string> ActionType()
 {
  Dictionary<string, string> dic = new Dictionary<string, string>();
  dic.Add("Show", "顯示");
  dic.Add("View", "查看");
  dic.Add("Add", "添加");
  dic.Add("Edit", "修改");
  dic.Add("Delete", "刪除");
  dic.Add("Audit", "審核");
  dic.Add("Reply", "回復(fù)");
  dic.Add("Confirm", "確認(rèn)");
  dic.Add("Cancel", "取消");
  dic.Add("Invalid", "作廢");
  dic.Add("Build", "生成");
  dic.Add("Instal", "安裝");
  dic.Add("Unload", "卸載");
  dic.Add("Back", "備份");
  dic.Add("Restore", "還原");
  dic.Add("Replace", "替換");
  return dic;
 }
 #endregion

 #region 替換URL
 /// <summary>
 /// 替換擴(kuò)展名
 /// </summary>
 public static string GetUrlExtension(string urlPage, string staticExtension)
 {
  int indexNum = urlPage.LastIndexOf('.');
  if (indexNum > 0)
  {
  return urlPage.Replace(urlPage.Substring(indexNum), "." + staticExtension);
  }
  return urlPage;
 }
 /// <summary>
 /// 替換擴(kuò)展名，如沒(méi)有擴(kuò)展名替換默認(rèn)首頁(yè)
 /// </summary>
 public static string GetUrlExtension(string urlPage, string staticExtension, bool defaultVal)
 {
  int indexNum = urlPage.LastIndexOf('.');
  if (indexNum > 0)
  {
  return urlPage.Replace(urlPage.Substring(indexNum), "." + staticExtension);
  }
  if (defaultVal)
  {
  if (urlPage.EndsWith("/"))
  {
   return urlPage + "index." + staticExtension;
  }
  else
  {
   return urlPage + "/index." + staticExtension;
  }
  }
  return urlPage;
 }
 #endregion

 #region 根據(jù)IP 獲取地名
 #region 獲取頁(yè)面ip
 /// <summary>
 /// 獲得當(dāng)前頁(yè)面客戶(hù)端的IP
 /// </summary>
 /// <returns>當(dāng)前頁(yè)面客戶(hù)端的IP</returns>
 public static string GetIP()
 {
  string result = HttpContext.Current.Request.ServerVariables["REMOTE_ADDR"];
  if (string.IsNullOrEmpty(result))
  result = HttpContext.Current.Request.ServerVariables["HTTP_X_FORWARDED_FOR"];

  if (string.IsNullOrEmpty(result))
  result = HttpContext.Current.Request.UserHostAddress;

  if (string.IsNullOrEmpty(result) || !Utils.IsIP(result))
  return "127.0.0.1";

  return result;
 }
 #endregion

 public static string GetstringIpAddress(string strIP)//strIP為IP
 {
  String urlString = "http://int.dpool.sina.com.cn/iplookup/iplookup.php?ip=" + GetIP();
  var request = WebRequest.Create(urlString) as HttpWebRequest;
  request.Method = "GET";
  request.ContentType = "application/x-www-form-urlencoded; charset=UTF-8";
  HttpWebResponse response = null;
  try
  {
  response = request.GetResponse() as HttpWebResponse;
  }
  catch (WebException ex)
  {
  response = ex.Response as HttpWebResponse;
  }
  string result = string.Empty;
  using (StreamReader reader = new StreamReader(response.GetResponseStream(), Encoding.Default))
  {
  result = reader.ReadToEnd();
  string[] sp1 = { "\t" };
  string[] temp = result.Split(sp1, StringSplitOptions.None);
  if (temp != null && temp.Length >= 6)
  {
   return temp[4] + "省" + temp[5] + "市";
  }
  else
  {
   return string.Empty;
  }
  }

 }
 #endregion

 public static bool WriteTxt(string str)
 {
  return WriteTxt(str, "/debugLog.txt");
 }
 /// <summary>
 /// 寫(xiě)調(diào)試日志 相對(duì)路徑
 /// </summary>
 /// <param name="str"></param>
 /// <param name="filepath"></param>
 /// <returns></returns>
 public static bool WriteTxt(string str,string filepath)
 {
  try
  {
  FileStream fs = new FileStream(HttpContext.Current.Request.MapPath(filepath==""?"/debugLog.txt":filepath), FileMode.Append);
  StreamWriter sw = new StreamWriter(fs);
  //開(kāi)始寫(xiě)入
  sw.WriteLine(str);
  //清空緩沖區(qū)
  sw.Flush();
  //關(guān)閉流
  sw.Close();
  fs.Close();
  }
  catch (Exception)
  {
  return false;
  }
  return true;
 }
 public static string SubBetweenStr(string str, string startstr, string endstr)
 {
  int sindex = str.IndexOf(startstr);
  int eindex = str.LastIndexOf(endstr);
  int slength = startstr.Length;
  return str.Substring(sindex + slength, eindex - sindex - slength);
 }
 /// <summary>
 /// 根據(jù)指定的密碼和哈希算法生成一個(gè)適合于存儲(chǔ)在配置文件中的哈希密碼
 /// </summary>
 /// <param name="str">要進(jìn)行哈希運(yùn)算的密碼</param>
 /// <param name="type"> 要使用的哈希算法</param>
 /// <returns>經(jīng)過(guò)哈希運(yùn)算的密碼</returns>
 public static string HashPasswordForStoringInConfigFile(string str, string type)
 {
  return FormsAuthentication.HashPasswordForStoringInConfigFile(str, type);
 }

 public static void ResponseWrite(string str)
 {
  HttpContext.Current.Response.Write(str);
  HttpContext.Current.Response.End();
 }

 /// <summary>
 /// unix時(shí)間轉(zhuǎn)換為datetime
 /// </summary>
 /// <param name="timeStamp"></param>
 /// <returns></returns>
 public static DateTime UnixTimeToTime(string timeStamp)
 {
  DateTime dtStart = TimeZone.CurrentTimeZone.ToLocalTime(new DateTime(1970, 1, 1));
  long lTime = long.Parse(timeStamp + "0000000");
  TimeSpan toNow = new TimeSpan(lTime);
  return dtStart.Add(toNow);
 }

 /// <summary>
 /// datetime轉(zhuǎn)換為unixtime
 /// </summary>
 /// <param name="time"></param>
 /// <returns></returns>
 public static int ConvertDateTimeInt(System.DateTime time)
 {
  System.DateTime startTime = TimeZone.CurrentTimeZone.ToLocalTime(new System.DateTime(1970, 1, 1));
  return (int)(time - startTime).TotalSeconds;
 }
 }

JKRequest.cs代碼:

/// <summary>
 /// Request操作類(lèi)
 /// </summary>
 public class JKRequest
 {
 /// <summary>
 /// 判斷當(dāng)前頁(yè)面是否接收到了Post請(qǐng)求
 /// </summary>
 /// <returns>是否接收到了Post請(qǐng)求</returns>
 public static bool IsPost()
 {
  return HttpContext.Current.Request.HttpMethod.Equals("POST");
 }

 /// <summary>
 /// 判斷當(dāng)前頁(yè)面是否接收到了Get請(qǐng)求
 /// </summary>
 /// <returns>是否接收到了Get請(qǐng)求</returns>
 public static bool IsGet()
 {
  return HttpContext.Current.Request.HttpMethod.Equals("GET");
 }

 /// <summary>
 /// 返回指定的服務(wù)器變量信息
 /// </summary>
 /// <param name="strName">服務(wù)器變量名</param>
 /// <returns>服務(wù)器變量信息</returns>
 public static string GetServerString(string strName)
 {
  if (HttpContext.Current.Request.ServerVariables[strName] == null)
  return "";
  return HttpContext.Current.Request.ServerVariables[strName].ToString();
 }

 /// <summary>
 /// 返回上一個(gè)頁(yè)面的地址
 /// </summary>
 /// <returns>上一個(gè)頁(yè)面的地址</returns>
 public static string GetUrlReferrer()
 {
  string retVal = null;
  if (retVal == null)
  return "";
  try
  {  
  retVal = HttpContext.Current.Request.UrlReferrer.ToString();
  }
  catch{}
  return retVal;
 }

 /// <summary>
 /// 得到當(dāng)前完整主機(jī)頭
 /// </summary>
 /// <returns></returns>
 public static string GetCurrentFullHost()
 {
  HttpRequest request = System.Web.HttpContext.Current.Request;
  if (!request.Url.IsDefaultPort)
  return string.Format("{0}:{1}", request.Url.Host, request.Url.Port.ToString());
  return request.Url.Host;
 }

 /// <summary>
 /// 得到主機(jī)頭
 /// </summary>
 public static string GetHost()
 {
  return HttpContext.Current.Request.Url.Host;
 }

 /// <summary>
 /// 得到主機(jī)名
 /// </summary>
 public static string GetDnsSafeHost()
 {
  return HttpContext.Current.Request.Url.DnsSafeHost;
 }

 /// <summary>
 /// 獲取當(dāng)前請(qǐng)求的原始 URL(URL 中域信息之后的部分,包括查詢(xún)字符串(如果存在))
 /// </summary>
 /// <returns>原始 URL</returns>
 public static string GetRawUrl()
 {
  return HttpContext.Current.Request.RawUrl;
 }

 /// <summary>
 /// 判斷當(dāng)前訪問(wèn)是否來(lái)自瀏覽器軟件
 /// </summary>
 /// <returns>當(dāng)前訪問(wèn)是否來(lái)自瀏覽器軟件</returns>
 public static bool IsBrowserGet()
 {
  string[] BrowserName = {"ie", "opera", "netscape", "mozilla", "konqueror", "firefox"};
  string curBrowser = HttpContext.Current.Request.Browser.Type.ToLower();
  for (int i = 0; i < BrowserName.Length; i++)
  {
  if (curBrowser.IndexOf(BrowserName[i]) >= 0)
   return true;
  }
  return false;
 }

 /// <summary>
 /// 判斷是否來(lái)自搜索引擎鏈接
 /// </summary>
 /// <returns>是否來(lái)自搜索引擎鏈接</returns>
 public static bool IsSearchEnginesGet()
 {
  if (HttpContext.Current.Request.UrlReferrer == null)
  return false;
  string[] SearchEngine = {"google", "yahoo", "msn", "baidu", "sogou", "sohu", "sina", "163", "lycos", "tom", "yisou", "iask", "soso", "gougou", "zhongsou"};
  string tmpReferrer = HttpContext.Current.Request.UrlReferrer.ToString().ToLower();
  for (int i = 0; i < SearchEngine.Length; i++)
  {
  if (tmpReferrer.IndexOf(SearchEngine[i]) >= 0)
   return true;
  }
  return false;
 }

 /// <summary>
 /// 獲得當(dāng)前完整Url地址
 /// </summary>
 /// <returns>當(dāng)前完整Url地址</returns>
 public static string GetUrl()
 {
  return HttpContext.Current.Request.Url.ToString();
 }

 /// <summary>
 /// 獲得指定Url參數(shù)的值
 /// </summary>
 /// <param name="strName">Url參數(shù)</param>
 /// <returns>Url參數(shù)的值</returns>
 public static string GetQueryString(string strName)
 {
  return GetQueryString(strName, false);
 }
 public static DateTime GetQueryDateTime(string strName)
 {
  return Utils.StrToDateTime(GetQueryString(strName));
 }
 /// <summary>
 /// 獲得指定Url參數(shù)的值
 /// </summary> 
 /// <param name="strName">Url參數(shù)</param>
 /// <param name="sqlSafeCheck">是否進(jìn)行SQL安全檢查</param>
 /// <returns>Url參數(shù)的值</returns>
 public static string GetQueryString(string strName, bool sqlSafeCheck)
 {
  if (HttpContext.Current.Request.QueryString[strName] == null)
  return "";

  if (sqlSafeCheck && !Utils.IsSafeSqlString(HttpContext.Current.Request.QueryString[strName]))
  return "unsafe string";

  return HttpContext.Current.Request.QueryString[strName];
 }


 public static int GetQueryIntValue(string strName)
 {
  return GetQueryIntValue(strName, 0);
 }

 /// <summary>
 /// 返回指定URL的參數(shù)值(Int型)
 /// </summary>
 /// <param name="strName">URL參數(shù)</param>
 /// <param name="defaultvalue">默認(rèn)值</param>
 /// <returns>返回指定URL的參數(shù)值</returns>
 public static int GetQueryIntValue(string strName, int defaultvalue)
 {
  if (HttpContext.Current.Request.QueryString[strName] == null || HttpContext.Current.Request.QueryString[strName].ToString() == string.Empty)
  return defaultvalue;
  else
  {
  Regex obj = new Regex("\\d+");
  Match objmach = obj.Match(HttpContext.Current.Request.QueryString[strName].ToString());
  if (objmach.Success)
   return Convert.ToInt32(objmach.Value);
  else
   return defaultvalue;
  }
 }


 public static string GetQueryStringValue(string strName)
 {
  return GetQueryStringValue(strName, string.Empty);
 }

 /// <summary>
 /// 返回指定URL的參數(shù)值(String型)
 /// </summary>
 /// <param name="strName">URL參數(shù)</param>
 /// <param name="defaultvalue">默認(rèn)值</param>
 /// <returns>返回指定URL的參數(shù)值</returns>
 public static string GetQueryStringValue(string strName, string defaultvalue)
 {
  if (HttpContext.Current.Request.QueryString[strName] == null || HttpContext.Current.Request.QueryString[strName].ToString() == string.Empty)
  return defaultvalue;
  else
  {
  Regex obj = new Regex("\\w+");
  Match objmach = obj.Match(HttpContext.Current.Request.QueryString[strName].ToString());
  if (objmach.Success)
   return objmach.Value;
  else
   return defaultvalue;
  }
 }
 /// <summary>
 /// 獲得當(dāng)前頁(yè)面的名稱(chēng)
 /// </summary>
 /// <returns>當(dāng)前頁(yè)面的名稱(chēng)</returns>
 public static string GetPageName()
 {
  string [] urlArr = HttpContext.Current.Request.Url.AbsolutePath.Split('/');
  return urlArr[urlArr.Length - 1].ToLower();
 }

 /// <summary>
 /// 返回表單或Url參數(shù)的總個(gè)數(shù)
 /// </summary>
 /// <returns></returns>
 public static int GetParamCount()
 {
  return HttpContext.Current.Request.Form.Count + HttpContext.Current.Request.QueryString.Count;
 }

 /// <summary>
 /// 獲得指定表單參數(shù)的值
 /// </summary>
 /// <param name="strName">表單參數(shù)</param>
 /// <returns>表單參數(shù)的值</returns>
 public static string GetFormString(string strName)
 {
  return GetFormString(strName, false);
 }

 /// <summary>
 /// 獲得指定表單參數(shù)的值
 /// </summary>
 /// <param name="strName">表單參數(shù)</param>
 /// <param name="sqlSafeCheck">是否進(jìn)行SQL安全檢查</param>
 /// <returns>表單參數(shù)的值</returns>
 public static string GetFormString(string strName, bool sqlSafeCheck)
 {
  if (HttpContext.Current.Request.Form[strName] == null)
  return "";

  if (sqlSafeCheck && !Utils.IsSafeSqlString(HttpContext.Current.Request.Form[strName]))
  return "unsafe string";

  return HttpContext.Current.Request.Form[strName];
 }
 /// <summary>
 /// 返回指定表單的參數(shù)值(Int型)
 /// </summary>
 /// <param name="strName">表單參數(shù)</param>
 /// <returns>返回指定表單的參數(shù)值(Int型)</returns>
 public static int GetFormIntValue(string strName)
 {
  return GetFormIntValue(strName, 0);
 }
 /// <summary>
 /// 返回指定表單的參數(shù)值(Int型)
 /// </summary>
 /// <param name="strName">表單參數(shù)</param>
 /// <param name="defaultvalue">默認(rèn)值</param>
 /// <returns>返回指定表單的參數(shù)值</returns>
 public static int GetFormIntValue(string strName, int defaultvalue)
 {
  if (HttpContext.Current.Request.Form[strName] == null || HttpContext.Current.Request.Form[strName].ToString() == string.Empty)
  return defaultvalue;
  else
  {
  Regex obj = new Regex("\\d+");
  Match objmach = obj.Match(HttpContext.Current.Request.Form[strName].ToString());
  if (objmach.Success)
   return Convert.ToInt32(objmach.Value);
  else
   return defaultvalue;
  }
 }
 /// <summary>
 /// 返回指定表單的參數(shù)值(String型)
 /// </summary>
 /// <param name="strName">表單參數(shù)</param>
 /// <returns>返回指定表單的參數(shù)值(String型)</returns>
 public static string GetFormStringValue(string strName)
 {
  return GetQueryStringValue(strName, string.Empty);
 }
 /// <summary>
 /// 返回指定表單的參數(shù)值(String型)
 /// </summary>
 /// <param name="strName">表單參數(shù)</param>
 /// <param name="defaultvalue">默認(rèn)值</param>
 /// <returns>返回指定表單的參數(shù)值</returns>
 public static string GetFormStringValue(string strName, string defaultvalue)
 {
  if (HttpContext.Current.Request.Form[strName] == null || HttpContext.Current.Request.Form[strName].ToString() == string.Empty)
  return defaultvalue;
  else
  {
  Regex obj = new Regex("\\w+");
  Match objmach = obj.Match(HttpContext.Current.Request.Form[strName].ToString());
  if (objmach.Success)
   return objmach.Value;
  else
   return defaultvalue;
  }
 }

 /// <summary>
 /// 獲得Url或表單參數(shù)的值, 先判斷Url參數(shù)是否為空字符串, 如為T(mén)rue則返回表單參數(shù)的值
 /// </summary>
 /// <param name="strName">參數(shù)</param>
 /// <returns>Url或表單參數(shù)的值</returns>
 public static string GetString(string strName)
 {
  return GetString(strName, false);
 }
 /// <summary>
 /// 獲得Url或表單參數(shù)的值, 先判斷Url參數(shù)是否為空字符串, 如為T(mén)rue則返回表單參數(shù)的值
 /// </summary>
 /// <param name="strName">參數(shù)</param>
 /// <param name="sqlSafeCheck">是否進(jìn)行SQL安全檢查</param>
 /// <returns>Url或表單參數(shù)的值</returns>
 public static string GetString(string strName, bool sqlSafeCheck)
 {
  if ("".Equals(GetQueryString(strName)))
  return GetFormString(strName, sqlSafeCheck);
  else
  return GetQueryString(strName, sqlSafeCheck);
 }
 public static string GetStringValue(string strName)
 {
  return GetStringValue(strName, string.Empty);
 }
 /// <summary>
 /// 獲得Url或表單參數(shù)的值, 先判斷Url參數(shù)是否為空字符串, 如為T(mén)rue則返回表單參數(shù)的值
 /// </summary>
 /// <param name="strName">參數(shù)</param>
 /// <param name="sqlSafeCheck">是否進(jìn)行SQL安全檢查</param>
 /// <returns>Url或表單參數(shù)的值</returns>
 public static string GetStringValue(string strName, string defaultvalue)
 {
  if ("".Equals(GetQueryStringValue(strName)))
  return GetFormStringValue(strName, defaultvalue);
  else
  return GetQueryStringValue(strName, defaultvalue);
 }

 /// <summary>
 /// 獲得指定Url參數(shù)的int類(lèi)型值
 /// </summary>
 /// <param name="strName">Url參數(shù)</param>
 /// <returns>Url參數(shù)的int類(lèi)型值</returns>
 public static int GetQueryInt(string strName)
 {
  return Utils.StrToInt(HttpContext.Current.Request.QueryString[strName], 0);
 }

 /// <summary>
 /// 獲得指定Url參數(shù)的int類(lèi)型值
 /// </summary>
 /// <param name="strName">Url參數(shù)</param>
 /// <param name="defValue">缺省值</param>
 /// <returns>Url參數(shù)的int類(lèi)型值</returns>
 public static int GetQueryInt(string strName, int defValue)
 {
  return Utils.StrToInt(HttpContext.Current.Request.QueryString[strName], defValue);
 }

 /// <summary>
 /// 獲得指定表單參數(shù)的int類(lèi)型值
 /// </summary>
 /// <param name="strName">表單參數(shù)</param>
 /// <returns>表單參數(shù)的int類(lèi)型值</returns>
 public static int GetFormInt(string strName)
 {
  return GetFormInt(strName, 0);
 }

 /// <summary>
 /// 獲得指定表單參數(shù)的int類(lèi)型值
 /// </summary>
 /// <param name="strName">表單參數(shù)</param>
 /// <param name="defValue">缺省值</param>
 /// <returns>表單參數(shù)的int類(lèi)型值</returns>
 public static int GetFormInt(string strName, int defValue)
 {
  return Utils.StrToInt(HttpContext.Current.Request.Form[strName], defValue);
 }

 /// <summary>
 /// 獲得指定Url或表單參數(shù)的int類(lèi)型值, 先判斷Url參數(shù)是否為缺省值, 如為T(mén)rue則返回表單參數(shù)的值
 /// </summary>
 /// <param name="strName">Url或表單參數(shù)</param>
 /// <param name="defValue">缺省值</param>
 /// <returns>Url或表單參數(shù)的int類(lèi)型值</returns>
 public static int GetInt(string strName, int defValue)
 {
  if (GetQueryInt(strName, defValue) == defValue)
  return GetFormInt(strName, defValue);
  else
  return GetQueryInt(strName, defValue);
 }

 /// <summary>
 /// 獲得指定Url參數(shù)的decimal類(lèi)型值
 /// </summary>
 /// <param name="strName">Url參數(shù)</param>
 /// <param name="defValue">缺省值</param>
 /// <returns>Url參數(shù)的decimal類(lèi)型值</returns>
 public static decimal GetQueryDecimal(string strName, decimal defValue)
 {
  return Utils.StrToDecimal(HttpContext.Current.Request.QueryString[strName], defValue);
 }

 /// <summary>
 /// 獲得指定表單參數(shù)的decimal類(lèi)型值
 /// </summary>
 /// <param name="strName">表單參數(shù)</param>
 /// <param name="defValue">缺省值</param>
 /// <returns>表單參數(shù)的decimal類(lèi)型值</returns>
 public static decimal GetFormDecimal(string strName, decimal defValue)
 {
  return Utils.StrToDecimal(HttpContext.Current.Request.Form[strName], defValue);
 }

 /// <summary>
 /// 獲得指定Url參數(shù)的float類(lèi)型值
 /// </summary>
 /// <param name="strName">Url參數(shù)</param>
 /// <param name="defValue">缺省值</param>
 /// <returns>Url參數(shù)的int類(lèi)型值</returns>
 public static float GetQueryFloat(string strName, float defValue)
 {
  return Utils.StrToFloat(HttpContext.Current.Request.QueryString[strName], defValue);
 }

 /// <summary>
 /// 獲得指定表單參數(shù)的float類(lèi)型值
 /// </summary>
 /// <param name="strName">表單參數(shù)</param>
 /// <param name="defValue">缺省值</param>
 /// <returns>表單參數(shù)的float類(lèi)型值</returns>
 public static float GetFormFloat(string strName, float defValue)
 {
  return Utils.StrToFloat(HttpContext.Current.Request.Form[strName], defValue);
 }

 /// <summary>
 /// 獲得指定Url或表單參數(shù)的float類(lèi)型值, 先判斷Url參數(shù)是否為缺省值, 如為T(mén)rue則返回表單參數(shù)的值
 /// </summary>
 /// <param name="strName">Url或表單參數(shù)</param>
 /// <param name="defValue">缺省值</param>
 /// <returns>Url或表單參數(shù)的int類(lèi)型值</returns>
 public static float GetFloat(string strName, float defValue)
 {
  if (GetQueryFloat(strName, defValue) == defValue)
  return GetFormFloat(strName, defValue);
  else
  return GetQueryFloat(strName, defValue);
 }

 /// <summary>
 /// 獲得當(dāng)前頁(yè)面客戶(hù)端的IP
 /// </summary>
 /// <returns>當(dāng)前頁(yè)面客戶(hù)端的IP</returns>
 public static string GetIP()
 {
  string result = HttpContext.Current.Request.ServerVariables["REMOTE_ADDR"];
  if (string.IsNullOrEmpty(result))
  result = HttpContext.Current.Request.ServerVariables["HTTP_X_FORWARDED_FOR"];
  if (string.IsNullOrEmpty(result))
  result = HttpContext.Current.Request.UserHostAddress;
  if (string.IsNullOrEmpty(result) || !Utils.IsIP(result))
  return "127.0.0.1";
  return result;
 }

 public static Stream GetInputStream()
 {
  return System.Web.HttpContext.Current.Request.InputStream;
 }

 }

WxPayHelper類(lèi)庫(kù)下的Utils類(lèi):

namespace WxPayHelper
{
 public class Utils
 {
 public static string GetUnifyUrlXml<T>(T t,string key,out string url,out string _sign)
 {
  Type type = typeof (T);
  Dictionary<string,string> dic = new Dictionary<string, string>();
  PropertyInfo[] pis = type.GetProperties();
  #region 組合url參數(shù)到字典里
  foreach (PropertyInfo pi in pis)
  {
  object val = pi.GetValue(t, null);
  if (val != null)
  {
   dic.Add(pi.Name, val.ToString());
  }
  }
  #endregion
  //字典排序
  var dictemp = dic.OrderBy(d => d.Key);
  #region 生成url字符串
  StringBuilder str = new StringBuilder();
  foreach (var item in dictemp)
  {
  str.AppendFormat("{0}={1}&", item.Key, item.Value);
  }
  #endregion
  var ourl= str.ToString().Trim('&');
  //加上key
  string tempsign = ourl + "&key="+key;
  //md5加密后，轉(zhuǎn)換成大寫(xiě)
  string sign = MD5(tempsign).ToUpper();
  //將簽名添加到字典中
  dic.Add("sign", sign);
  _sign = sign;
  url = str.AppendFormat("sign={0}",sign).ToString();

  LogHelper.WriteFile(url);
  //生成請(qǐng)求的內(nèi)容，并返回
  return parseRequestXML(dic);
 }

 public static string GetUnifyRequestXml<T>(T t, string key, out string url, out string _sign)
 {
  Type type = typeof(T);
  Dictionary<string, string> dic = new Dictionary<string, string>();
  PropertyInfo[] pis = type.GetProperties();
  #region 組合url參數(shù)到字典里
  foreach (PropertyInfo pi in pis)
  {
  object val = pi.GetValue(t, null);
  if (val != null)
  {
   dic.Add(pi.Name, val.ToString());
  }
  }
  #endregion
  //字典排序
  var dictemp = dic.OrderBy(d => d.Key);
  #region 生成url字符串
  StringBuilder str = new StringBuilder();
  foreach (var item in dictemp)
  {
  str.AppendFormat("{0}={1}&", item.Key, item.Value);
  }
  #endregion
  var ourl = str.ToString().Trim('&');
  //加上key
  string tempsign = ourl + "&key=" + key;
  //md5加密后，轉(zhuǎn)換成大寫(xiě)
  string sign = MD5(tempsign).ToUpper();
  //將簽名添加到字典中
  dic.Add("sign", sign);
  _sign = sign;
  url = str.AppendFormat("sign={0}", sign).ToString();

  LogHelper.WriteFile(url);
  //生成請(qǐng)求的內(nèi)容，并返回
  return parseRequestXML(dic);
 }

 public static string parseRequestXML(Dictionary<string, string> parameters)
 {
  StringBuilder sb = new StringBuilder();
  sb.Append("<xml>");
  foreach (KeyValuePair<string, string> k in parameters)
  {
  if (k.Key == "detail")
  {
   sb.Append("<" + k.Key + "><![CDATA[" + k.Value + "]]></" + k.Key + ">");
  }
  else
  {
   sb.Append("<" + k.Key + ">" + k.Value + "</" + k.Key + ">");
  }
  }
  sb.Append("</xml>");
  LogHelper.WriteFile(sb.ToString());
  return sb.ToString();
 }


 public static string parseXML(Dictionary<string, string> parameters)
 {
  StringBuilder sb = new StringBuilder();
  sb.Append("<xml>");
  foreach (string k in parameters.Keys)
  {
  string v = (string)parameters[k];
  if (Regex.IsMatch(v, @"^[0-9.]$"))
  {

   sb.Append("<" + k + ">" + v + "</" + k + ">");
  }
  else
  {
   sb.Append("<" + k + "><![CDATA[" + v + "]]></" + k + ">");
  }

  }
  //foreach (KeyValuePair<string, string> k in parameters)
  //{
  // if (k.Key == "detail")
  // {
  // sb.Append("<" + k.Key + "><![CDATA[" + k.Value + "]]></" + k.Key + ">");
  // }
  // else
  // {
  // sb.Append("<" + k.Key + ">" + k.Value + "</" + k.Key + ">");
  // }
  //}
  sb.Append("</xml>");
  LogHelper.WriteFile(sb.ToString());
  return sb.ToString();
 }

 /// <summary>
 /// 獲取32位隨機(jī)數(shù)（GUID）
 /// </summary>
 /// <returns></returns>
 public static string GetRandom()
 {
  return Guid.NewGuid().ToString("N");
 }
 /// <summary>
 /// 獲取微信版本
 /// </summary>
 /// <param name="ua"></param>
 /// <returns></returns>
 public static string GetWeiXinVersion(string ua)
 {
  int Last = ua.LastIndexOf("MicroMessenger");
  string[] wxversion = ua.Remove(0, Last).Split(' ');
  return wxversion[0].Split('/')[1].Substring(0, 3);
 }

 #region MD5加密
 public static string MD5(string pwd)
 {
  MD5 md5 = new MD5CryptoServiceProvider();
  byte[] data = System.Text.Encoding.UTF8.GetBytes(pwd);
  byte[] md5data = md5.ComputeHash(data);
  md5.Clear();
  string str = "";
  for (int i = 0; i < md5data.Length; i++)
  {
  str += md5data[i].ToString("x").PadLeft(2, '0');
  }
  return str;
 }


 #endregion

 public static string HttpPost(string url, string param)
 {
  HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(url);
  request.Method = "POST";
  request.ContentType = "application/x-www-form-urlencoded";
  request.Accept = "*/*";
  request.Timeout = 15000;
  request.AllowAutoRedirect = false;

  StreamWriter requestStream = null;
  WebResponse response = null;
  string responseStr = null;

  try
  {
  requestStream = new StreamWriter(request.GetRequestStream());
  requestStream.Write(param);
  requestStream.Close();

  response = request.GetResponse();
  if (response != null)
  {
   StreamReader reader = new StreamReader(response.GetResponseStream(), Encoding.UTF8);
   responseStr = reader.ReadToEnd();
   reader.Close();
  }
  }
  catch (Exception)
  {
  throw;
  }
  finally
  {
  request = null;
  requestStream = null;
  response = null;
  }

  return responseStr;
 }

 /// <summary>
 /// datetime轉(zhuǎn)換為unixtime
 /// </summary>
 /// <param name="time"></param>
 /// <returns></returns>
 public static int ConvertDateTimeInt(System.DateTime time)
 {
  System.DateTime startTime = TimeZone.CurrentTimeZone.ToLocalTime(new System.DateTime(1970, 1, 1));
  return (int)(time - startTime).TotalSeconds;
 }
 public static bool WriteTxt(string str)
 {
  try
  {
  FileStream fs = new FileStream(HttpContext.Current.Request.MapPath("/bugLog.txt"), FileMode.Append);
  StreamWriter sw = new StreamWriter(fs);
  //開(kāi)始寫(xiě)入
  sw.WriteLine(str);
  //清空緩沖區(qū)
  sw.Flush();
  //關(guān)閉流
  sw.Close();
  fs.Close();
  }
  catch (Exception)
  {
  return false;
  }
  return true;
 }

 /// <summary>
 /// 生成二維碼流
 /// </summary>
 /// <param name="qrcontent"></param>
 /// <returns></returns>
 public static MemoryStream GetQrCodeStream(string qrcontent)
 {
  //誤差校正水平
  ErrorCorrectionLevel ecLevel = ErrorCorrectionLevel.M;
  //空白區(qū)域
  QuietZoneModules quietZone = QuietZoneModules.Zero;
  int ModuleSize = 120;//大小
  QrCode qrCode;
  var encoder = new QrEncoder(ecLevel);
  //對(duì)內(nèi)容進(jìn)行編碼，并保存生成的矩陣
  if (encoder.TryEncode(qrcontent,out qrCode))
  {
  var render = new GraphicsRenderer(new FixedCodeSize(ModuleSize, quietZone));
  MemoryStream stream = new MemoryStream();
  render.WriteToStream(qrCode.Matrix, ImageFormat.Jpeg,stream);
  return stream;
  }
  return null;
 }

 public static void GetQrCode(string qrcontent)
 {
  MemoryStream ms = GetQrCodeStream(qrcontent);
  HttpContext.Current.Response.ClearContent();
  HttpContext.Current.Response.ContentType = "image/Png";
  HttpContext.Current.Response.BinaryWrite(ms.ToArray());

 }


 }
}

看完了這篇文章，相信你對(duì)“如何使用ASP.NET實(shí)現(xiàn)微信JS-SDK支付”有了一定的了解，如果想了解更多相關(guān)知識(shí)，歡迎關(guān)注億速云行業(yè)資訊頻道，感謝各位的閱讀！