c# 基础类

其他 2018-07-10 17:43:54 阅读次数: 0

using WL.Infrastructure.Http;

using  System;
using  System.Collections.Generic;
using  System.IO;
using  System.Linq;
using  System.Text;
using  System.Text.RegularExpressions;
using  System.Web;
using  System.Drawing;
using  System.Drawing.Imaging;
using  System.Drawing.Drawing2D;
 
namespace  WL.Infrastructure.Common
{
     public  class  Common
     {
         private  static  int  seed = 1;
         private  static  int  key_seed = 1;
         private  static  int  noseed = 1;
         private  static  int  domseed = 1;
         private  static  int  geseed = 1;
         /// <summary>
         /// 取得客户端真实IP。如果有代理则取第一个非内网地址
         /// </summary>
         public  static  string  IPAddress
         {
             get
             {
                 string  result = String.Empty;
 
                 result = HttpContext.Current.Request.ServerVariables[ "HTTP_X_FORWARDED_FOR" ];
                 if  (result !=  null  && result != String.Empty)
                 {
                     //可能有代理;
                     if  (result.IndexOf( "." ) == -1)     //没有“.”肯定是非IPv4格式;
                         result =  null ;
                     else
                     {
                         if  (result.IndexOf( "," ) != -1)
                         {
                             //有“,”，估计多个代理。取第一个不是内网的IP。;
                             result = result.Replace( " " ,  "" ).Replace( "'" ,  "" );
                             string [] temparyip = result.Split( ",;" .ToCharArray());
                             for  ( int  i = 0; i < temparyip.Length; i++)
                             {
                                 if  (IsIPAddress(temparyip[i])
                                     && temparyip[i].Substring(0, 3) !=  "10."
                                     && temparyip[i].Substring(0, 7) !=  "192.168"
                                     && temparyip[i].Substring(0, 7) !=  "172.16." )
                                 {
                                     return  temparyip[i];     //找到不是内网的地址 ;
                                 }
                             }
                         }
                         else  if  (IsIPAddress(result))  //代理即是IP格式;
                             return  result;
                         else
                             result =  null ;     //代理中的内容 非IP，取IP ;
                     }
 
                 }
 
                 string  IpAddress = (HttpContext.Current.Request.ServerVariables[ "HTTP_X_FORWARDED_FOR" ] !=  null  && HttpContext.Current.Request.ServerVariables[ "HTTP_X_FORWARDED_FOR" ] != String.Empty) ? HttpContext.Current.Request.ServerVariables[ "HTTP_X_FORWARDED_FOR" ] : HttpContext.Current.Request.ServerVariables[ "REMOTE_ADDR" ];
 
 
 
                 if  ( null  == result || result == String.Empty)
                     result = HttpContext.Current.Request.ServerVariables[ "REMOTE_ADDR" ];
 
                 if  (result ==  null  || result == String.Empty)
                     result = HttpContext.Current.Request.UserHostAddress;
                 if  (result ==  "::1" )
                 {
                     result =  "127.0.0.1" ;
                 }
                 return  result;
             }
         }
         /// <summary>
         /// 绕过cnd获取真实ip
         /// </summary>
         /// <returns></returns>
         public  static  string  GetUserIp()
         {
             string  userIP =  "未获取用户IP" ;
 
             try
             {
                 if  (HttpContext.Current ==  null
             || HttpContext.Current.Request ==  null
             || HttpContext.Current.Request.ServerVariables ==  null )
                     return  "" ;
 
                 string  CustomerIP =  "" ;
 
                 //CDN加速后取到的IP 
                 CustomerIP = HttpContext.Current.Request.Headers[ "Cdn-Src-Ip" ];
                 if  (! string .IsNullOrEmpty(CustomerIP))
                 {
                     return  CustomerIP;
                 }
 
                 CustomerIP = HttpContext.Current.Request.ServerVariables[ "HTTP_X_FORWARDED_FOR" ];
 
                 if  (!String.IsNullOrEmpty(CustomerIP))
                     return  CustomerIP;
 
                 if  (HttpContext.Current.Request.ServerVariables[ "HTTP_VIA" ] !=  null )
                 {
                     CustomerIP = HttpContext.Current.Request.ServerVariables[ "HTTP_X_FORWARDED_FOR" ];
                     if  (CustomerIP ==  null )
                         CustomerIP = HttpContext.Current.Request.ServerVariables[ "REMOTE_ADDR" ];
                 }
                 else
                 {
                     CustomerIP = HttpContext.Current.Request.ServerVariables[ "REMOTE_ADDR" ];
 
                 }
 
                 if  ( string .Compare(CustomerIP,  "unknown" ,  true ) == 0)
                     return  HttpContext.Current.Request.UserHostAddress;
                 return  CustomerIP;
             }
             catch  { }
 
             return  userIP;
         }
         /**/
         /// <summary>
         /// 判断是否是IP地址格式 0.0.0.0
         /// </summary>
         /// <param name="str1">待判断的IP地址</param>
         /// <returns>true or false</returns>
         public  static  bool  IsIPAddress( string  str1)
         {
             if  (str1 ==  null  || str1 ==  string .Empty || str1.Length < 7 || str1.Length > 15)  return  false ;
 
             string  regformat =  @"^/d{1,3}[/.]/d{1,3}[/.]/d{1,3}[/.]/d{1,3}$" ;
 
             Regex regex =  new  Regex(regformat, RegexOptions.IgnoreCase);
             return  regex.IsMatch(str1);
         }
         /// <summary>
         /// 时间转换时间戳
         /// </summary>
         /// <param name="time"></param>
         /// <returns></returns>
         public  static  string  ConvertDateTimeInt( string  time)
         {
             DateTime dtStart = TimeZone.CurrentTimeZone.ToLocalTime( new  DateTime(1970, 1, 1));
             DateTime dtNow = DateTime.Parse(time);
             TimeSpan toNow = dtNow.Subtract(dtStart);
             string  timeStamp = toNow.Ticks.ToString();
             timeStamp = timeStamp.Substring(0, timeStamp.Length - 7);
             return  timeStamp;
         }
         /// <summary>
         /// 时间戳转换时间
         /// </summary>
         /// <param name="datestr"></param>
         /// <returns></returns>
         public  static  DateTime ConvertDate( string  datestr)
         {
             DateTime dtStart = TimeZone.CurrentTimeZone.ToLocalTime( new  DateTime(1970, 1, 1));
             long  lTime =  long .Parse(datestr +  "0000000" );
             TimeSpan toNow =  new  TimeSpan(lTime);
             DateTime dtResult = dtStart.Add(toNow);
             return  dtResult;
         }
         /// <summary>
         /// 转换时间
         /// </summary>
         /// <param name="time"></param>
         /// <returns></returns>
         public  static  string  ConvertDateTimeInt_flot( string  time)
         {
             DateTime dtStart = TimeZone.CurrentTimeZone.ToLocalTime( new  DateTime(1970, 1, 1));
             DateTime dtNow = DateTime.Parse(time);
             TimeSpan toNow = dtNow.Subtract(dtStart);
             string  timeStamp = toNow.Ticks.ToString();
             timeStamp = timeStamp.Substring(0, timeStamp.Length - 4);
             return  timeStamp;
         }
         /// <summary>
         /// 上传
         /// </summary>
         /// <param name="_rootPath"></param>
         /// <param name="_file"></param>
         /// <param name="_filename"></param>
         /// <param name="type_s"></param>
         /// <returns></returns>
         public  static  string  FileUploader( string  _rootPath, HttpPostedFileBase _file,  string  _filename =  null ,  string  type_s =  "" )
         {
             string  sFileName = _filename;
             if  (_file !=  null )
             {
                 string  _filePath = _file.FileName;
                 if  (_filePath !=  string .Empty)
                 {
                     string  _fileType = _filePath.Substring(_filePath.LastIndexOf( "." ));
                     string  sFileRoot = _rootPath;
                     if  (!System.IO.Directory.Exists(sFileRoot))
                         System.IO.Directory.CreateDirectory(sFileRoot);
                     if  (sFileName ==  null )
                     {
                         if  (type_s !=  "" )
                         {
                             sFileName = DateTime.Now.ToString( "yyyyMMddHHmmssms" ) + type_s;
                         }
                         else
                         {
                             sFileName = DateTime.Now.ToString( "yyyyMMddHHmmssms" ) + _fileType;
                         }
                     }
                     else
                     {
                         if  (type_s !=  "" )
                         {
                             sFileName = sFileName + type_s;
                         }
                         else
                         {
                             sFileName = sFileName + _fileType;
                         }
                     }
                     string  sFilePath = sFileRoot +  "\\"  + sFileName;
                     _file.SaveAs(sFilePath);
                 }
             }
             return  sFileName;
         }
         /// <summary>
         /// 根据路径把文件转换成数据流
         /// </summary>
         /// <param name="strpath"></param>
         /// <returns></returns>
         public  static  byte [] Returnbyte( string  strpath)
         {
             // 以二进制方式读文件
             FileStream fsMyfile =  new  FileStream(strpath, FileMode.OpenOrCreate, FileAccess.ReadWrite);
             // 创建一个二进制数据流读入器，和打开的文件关联
             BinaryReader brMyfile =  new  BinaryReader(fsMyfile);
             // 把文件指针重新定位到文件的开始
             brMyfile.BaseStream.Seek(0, SeekOrigin.Begin);
             byte [] bytes = brMyfile.ReadBytes(Convert.ToInt32(fsMyfile.Length.ToString()));
             // 关闭以上new的各个对象
             brMyfile.Close();
             return  bytes;
         }
         public  static  void  DeleteFile( string  filepatch)
         {
             FileInfo file =  new  FileInfo(filepatch); //指定文件路径
             if  (file.Exists) //判断文件是否存在
             {
                 file.Attributes = FileAttributes.Normal; //将文件属性设置为普通,比方说只读文件设置为普通
                 file.Delete(); //删除文件
             }
         }
         /// 取得某月的第一天
         /// </summary>
         /// <param name="datetime">要取得月份第一天的时间</param>
         /// <returns></returns>
         private  DateTime FirstDayOfMonth(DateTime datetime)
         {
             return  datetime.AddDays(1 - datetime.Day);
         }
         /// <summary>
         /// 取得某月的最后一天
         /// </summary>
         /// <param name="datetime">要取得月份最后一天的时间</param>
         /// <returns></returns>
         private  DateTime LastDayOfMonth(DateTime datetime)
         {
             return  datetime.AddDays(1 - datetime.Day).AddMonths(1).AddDays(-1);
         }
 
         /// <summary>
         /// 取得上个月第一天
         /// </summary>
         /// <param name="datetime">要取得上个月第一天的当前时间</param>
         /// <returns></returns>
         public  DateTime FirstDayOfPreviousMonth(DateTime datetime)
         {
             return  datetime.AddDays(1 - datetime.Day).AddMonths(-1);
         }
 
         /// <summary>
         /// 取得上个月的最后一天
         /// </summary>
         /// <param name="datetime">要取得上个月最后一天的当前时间</param>
         /// <returns></returns>
         public  DateTime LastDayOfPrdviousMonth(DateTime datetime)
         {
             return  datetime.AddDays(1 - datetime.Day).AddDays(-1);
         }
 
         /// <summary>
         /// 取得上周的第一天
         /// </summary>
         /// <param name="datetime">要取得上周最后一天的当前时间</param>
         /// <returns></returns>
         public  static  DateTime FirstDayOfPrdviousWeek(DateTime datetime)
         {
             //星期一为第一天 
             int  weeknow = Convert.ToInt32(datetime.DayOfWeek);
  
             //因为是以星期一为第一天，所以要判断weeknow等于0时，要向前推6天。 
             weeknow = (weeknow == 0 ? (7 - 1) : (weeknow - 1));
             int  daydiff = (-1) * weeknow;
  
             //本周第一天 
             string  FirstDay = datetime.AddDays(daydiff).ToString( "yyyy-MM-dd" );
             return  Convert.ToDateTime(FirstDay);
         }
 
         /// <summary>
         /// 取得上周的最后一天
         /// </summary>
         /// <param name="datetime">要取得上周最后一天的当前时间</param>
         /// <returns></returns>
         public  static  DateTime LastDayOfPrdviousWeek(DateTime datetime)
         {
             //星期天为最后一天 
             int  weeknow = Convert.ToInt32(datetime.DayOfWeek);
             weeknow = (weeknow == 0 ? 7 : weeknow);
             int  daydiff = (7 - weeknow);
 
             //本周最后一天 
             string  LastDay = datetime.AddDays(daydiff).ToString( "yyyy-MM-dd" );
             return  Convert.ToDateTime(LastDay);
         }
 
         /// <summary>
         /// 判断字符串是否为正整数
         /// </summary>
         /// <param name="str">要判断的字符串对象</param>
         /// <returns></returns>
         public  static  bool  IsInt( string  str)
         {
             bool  isInt =  false ;
             if  (! string .IsNullOrEmpty(str))
             {
                 isInt = Regex.IsMatch(str,  @"^(0|([1-9]\d*))$" );
             }
             return  isInt;
         }
 
         /// <summary>
         /// 判断是否为DateTime
         /// </summary>
         /// <param name="strDate"></param>
         /// <returns></returns>
         public  static  bool  IsDateTime( string  strDate)
         {
             try
             {
                 DateTime.Parse(strDate);
                 return  true ;
             }
             catch
             {
                 return  false ;
             }
         }
 
         /// <summary>
         /// 生成单号
         /// </summary>
         /// <param name="channel"></param>
         /// <returns></returns>
         public  static  string  GetOrderNo()
         {
             if  (seed ==  int .MaxValue)
             {
                 seed = 1;
             }
             seed++;
             string  tbout_trade_no =  "" ;
             string  guid = Guid.NewGuid().ToString();
             string  last = guid.Replace( "-" ,  "" );
             char [] cc = last.ToCharArray();
             StringBuilder sb =  new  StringBuilder(4);
             Random rd =  new  Random(( unchecked (( int )DateTime.Now.Ticks + seed)));
             for  ( int  i = 0; i < 6; i++)
             {
                 sb.Append(cc[rd.Next(cc.Length)]);
             }
 
             tbout_trade_no = sb +  "-"  + DateTime.Now.ToString( "yyyyMMddHHmmssff" );
             return  tbout_trade_no;
         }
         /// <summary>
         /// 生成密匙
         /// </summary>
         /// <param name="mch_id"></param>
         /// <returns></returns>
         public  static  string  GetGGAPIKey( string  num_id)
         {
             if  (key_seed ==  int .MaxValue)
             {
                 key_seed = 1;
             }
             key_seed++;
             string  key =  "" ;
             char [] constant = { '0' , '1' , '2' , '3' , '4' , '5' , '6' , '7' , '8' , '9' ,
                                'a' , 'b' , 'c' , 'd' , 'e' , 'f' , 'g' , 'h' , 'i' , 'j' , 'k' , 'l' , 'm' , 'n' , 'o' , 'p' , 'q' , 'r' , 's' , 't' , 'u' , 'v' , 'w' , 'x' , 'y' , 'z' ,
                                'A' , 'B' , 'C' , 'D' , 'E' , 'F' , 'G' , 'H' , 'I' , 'J' , 'K' , 'L' , 'M' , 'N' , 'O' , 'P' , 'Q' , 'R' , 'S' , 'T' , 'U' , 'V' , 'W' , 'X' , 'Y' , 'Z' };
             StringBuilder sb =  new  StringBuilder(4);
             for  ( int  i = 0; i < 5; i++)
             {
                 Random rd =  new  Random(( unchecked (( int )DateTime.Now.Ticks + i)));
                 sb.Append(constant[rd.Next(62)]);
             }
             key = MD5.Md5UTF8(num_id + sb).ToLower();
             return  key;
         }
         /// <summary>
         /// PostUTF8格式的JSON
         /// </summary>
         /// <param name="json"></param>
         /// <param name="url"></param>
         /// <returns></returns>
         public  static  string  PostUtf8Json( string  json,  string  url,  int  timeout = 1000000)
         {
             byte [] encodebytes = System.Text.Encoding.UTF8.GetBytes(json);
             HttpHelper helper =  new  HttpHelper();
             HttpItem item =  new  HttpItem();
             item.URL = url;
             item.Timeout = timeout;
             item.Method =  "POST" ;
             item.PostdataByte = encodebytes;
             item.PostEncoding = Encoding.UTF8;
             item.PostDataType = PostDataType.Byte;
             HttpResult result = helper.GetHtml(item);
             string  msg =  "" ;
             if  (( int )result.StatusCode < 400)
             {
                 msg = result.Html;
                 if  (msg ==  "操作超时" )
                 {
                     //LoggerFactory.Current.Create().LogError("请求错误，状态码为" + (int)result.StatusCode + ",url为" + url);
                     msg =  "" ;
                 }
             }
             else
             {
                 //LoggerFactory.Current.Create().LogError("请求错误，状态码为" + (int)result.StatusCode + ",url为" + url);
             }
             return  msg;
         }
         /// <summary>
         /// PostUTF8格式的Form
         /// </summary>
         /// <param name="json"></param>
         /// <param name="url"></param>
         /// <returns></returns>
         public  static  string  PostUtf8Form( string  json,  string  url,  int  timeout = 1000000)
         {
             byte [] encodebytes = System.Text.Encoding.UTF8.GetBytes(json);
             HttpHelper helper =  new  HttpHelper();
             HttpItem item =  new  HttpItem();
             item.URL = url;
             item.Timeout = timeout;
             item.Method =  "POST" ;
             item.Allowautoredirect =  true ;
             item.ContentType =  "application/x-www-form-urlencoded" ;
             item.PostdataByte = encodebytes;
             item.PostEncoding = Encoding.UTF8;
             item.PostDataType = PostDataType.Byte;
             HttpResult result = helper.GetHtml(item);
             string  msg =  "" ;
             if  (( int )result.StatusCode < 400)
             {
                 msg = result.Html;
                 if  (msg ==  "操作超时" )
                 {
                     //LoggerFactory.Current.Create().LogError("请求错误，状态码为" + (int)result.StatusCode + ",url为" + url);
                     msg =  "" ;
                 }
             }
             else
             {
                 //LoggerFactory.Current.Create().LogError("请求错误，状态码为" + (int)result.StatusCode + ",url为" + url);
             }
             return  msg;
         }
         /// <summary>
         /// PostGB2312格式的表单
         /// </summary>
         /// <param name="json"></param>
         /// <param name="url"></param>
         /// <returns></returns>
         public  static  string  PostGB2312Form( string  json,  string  url,  int  timeout = 5000)
         {
             byte [] encodebytes = System.Text.Encoding.GetEncoding( "GB2312" ).GetBytes(json);
             HttpHelper helper =  new  HttpHelper();
             HttpItem item =  new  HttpItem();
             item.URL = url;
             item.Timeout = timeout;
             item.Method =  "POST" ;
             item.Allowautoredirect =  true ;
             item.ContentType =  "application/x-www-form-urlencoded" ;
             item.PostdataByte = encodebytes;
             item.PostEncoding = Encoding.GetEncoding( "GB2312" );
             item.PostDataType = PostDataType.Byte;
             HttpResult result = helper.GetHtml(item);
             string  msg =  "" ;
             if  (( int )result.StatusCode < 400)
             {
                 msg = result.Html;
                 if  (msg ==  "操作超时" )
                 {
                     //LoggerFactory.Current.Create().LogError("请求错误，状态码为" + (int)result.StatusCode + ",url为" + url);
                     msg =  "" ;
                 }
             }
             else
             {
                 //LoggerFactory.Current.Create().LogError("请求错误，状态码为" + (int)result.StatusCode + ",url为" + url);
             }
             return  msg;
         }
         /// <summary>
         /// PostUTF8格式的JSON
         /// </summary>
         /// <param name="json"></param>
         /// <param name="url"></param>
         /// <returns></returns>
         public  static  string  PostUtf8File( byte [] encodebytes,  string  url,  int  timeout = 1000000)
         {
             //byte[] encodebytes = System.Text.Encoding.UTF8.GetBytes(json);
             HttpHelper helper =  new  HttpHelper();
             HttpItem item =  new  HttpItem();
             item.URL = url;
             item.Timeout = timeout;
             item.Method =  "POST" ;
             item.ContentType =  "multipart/form-data" ;
             item.PostdataByte = encodebytes;
             item.PostEncoding = Encoding.UTF8;
             item.PostDataType = PostDataType.Byte;
             HttpResult result = helper.GetHtml(item);
             string  msg =  "" ;
             if  (( int )result.StatusCode < 400)
             {
                 msg = result.Html;
                 if  (msg ==  "操作超时" )
                 {
                     //LoggerFactory.Current.Create().LogError("请求错误，状态码为" + (int)result.StatusCode + ",url为" + url);
                     msg =  "" ;
                 }
             }
             else
             {
                 //LoggerFactory.Current.Create().LogError("请求错误，状态码为" + (int)result.StatusCode + ",url为" + url);
             }
             return  msg;
         }
         /// <summary>
         /// Get格式
         /// </summary>
         /// <param name="json"></param>
         /// <param name="url"></param>
         /// <returns></returns>
         public  static  string  GetUrl( string  url,  int  timeout = 1000000)
         {
             HttpHelper helper =  new  HttpHelper();
             HttpItem item =  new  HttpItem();
             item.Timeout = timeout;
             item.URL = url;
             HttpResult result = helper.GetHtml(item);
             string  msg =  "" ;
             if  (( int )result.StatusCode < 400)
             {
                 msg = result.Html;
                 if  (msg ==  "操作超时" )
                 {
                     //LoggerFactory.Current.Create().LogError("请求错误，状态码为" + (int)result.StatusCode + ",url为" + url);
                     msg =  "" ;
                 }
             }
             else
             {
                 //LoggerFactory.Current.Create().LogError("请求错误，状态码为" + (int)result.StatusCode + ",url为" + url);
             }
             return  msg;
         }
         /// <summary>
         /// 生成随机字符串
         /// </summary>
         /// <returns></returns>
         public  static  string  get_noce_str()
         {
             if  (noseed ==  int .MaxValue)
             {
                 noseed = 1;
             }
             noseed++;
             char [] constant = { '0' , '1' , '2' , '3' , '4' , '5' , '6' , '7' , '8' , '9' ,
                                'a' , 'b' , 'c' , 'd' , 'e' , 'f' , 'g' , 'h' , 'i' , 'j' , 'k' , 'l' , 'm' , 'n' , 'o' , 'p' , 'q' , 'r' , 's' , 't' , 'u' , 'v' , 'w' , 'x' , 'y' , 'z' ,
                                'A' , 'B' , 'C' , 'D' , 'E' , 'F' , 'G' , 'H' , 'I' , 'J' , 'K' , 'L' , 'M' , 'N' , 'O' , 'P' , 'Q' , 'R' , 'S' , 'T' , 'U' , 'V' , 'W' , 'X' , 'Y' , 'Z' };
             StringBuilder sb =  new  StringBuilder(16);
             Random rd =  new  Random(( unchecked (( int )DateTime.Now.Ticks + noseed)));
             for  ( int  i = 0; i < 16; i++)
             {
                 sb.Append(constant[rd.Next(62)]);
             }
             return  sb.ToString();
         }
         /// <summary>
         /// 生成6位邀请码
         /// </summary>
         /// <returns></returns>
         public  static  string  get_generate_str()
         {
             if  (geseed ==  int .MaxValue)
             {
                 geseed = 1;
             }
             geseed++;
             char [] constant = { '0' , '1' , '2' , '3' , '4' , '5' , '6' , '7' , '8' , '9' ,
                                'a' , 'b' , 'c' , 'd' , 'e' , 'f' , 'g' , 'h' , 'i' , 'j' , 'k' , 'l' , 'm' , 'n' , 'o' , 'p' , 'q' , 'r' , 's' , 't' , 'u' , 'v' , 'w' , 'x' , 'y' , 'z' ,
                                'A' , 'B' , 'C' , 'D' , 'E' , 'F' , 'G' , 'H' , 'I' , 'J' , 'K' , 'L' , 'M' , 'N' , 'O' , 'P' , 'Q' , 'R' , 'S' , 'T' , 'U' , 'V' , 'W' , 'X' , 'Y' , 'Z' };
             StringBuilder sb =  new  StringBuilder(6);
             Random rd =  new  Random(( unchecked (( int )DateTime.Now.Ticks + geseed)));
             for  ( int  i = 0; i < 6; i++)
             {
                 sb.Append(constant[rd.Next(62)]);
             }
             return  sb.ToString();
         }
         /// <summary>
         /// 生成6位订单号
         /// </summary>
         /// <returns></returns>
         public  static  string  Nrandom()
         {
             if  (domseed ==  int .MaxValue)
             {
                 domseed = 1;
             }
             domseed++;
             string  rm =  "" ;
             Random rd =  new  Random(( unchecked (( int )DateTime.Now.Ticks + domseed)));
             for  ( int  i = 0; i < 6; i++)
             {
                 rm += rd.Next(0, 9).ToString();
             }
             return  rm;
         }
         /// <summary>
         /// 把数组所有元素，按照“参数=参数值”的模式用“&”字符拼接成字符串，并对参数值做urlencode
         /// </summary>
         /// <param name="sArray">需要拼接的数组</param>
         /// <param name="code">字符编码</param>
         /// <returns>拼接完成以后的字符串</returns>
         public  static  string  CreateLinkStringA(SortedDictionary< string ,  string > dicArray)
         {
             StringBuilder prestr =  new  StringBuilder();
             foreach  (KeyValuePair< string ,  string > temp  in  dicArray)
             {
                 prestr.Append(temp.Key +  "="  + temp.Value +  "&" );
             }
 
             //去掉最後一個&字符
             int  nLen = prestr.Length;
             prestr.Remove(nLen - 1, 1);
 
             return  prestr.ToString();
         }
         /// <summary>
         /// 把数组所有元素，按照“参数=参数值”的模式用“&”字符拼接成字符串，并对参数值做urlencode
         /// </summary>
         /// <param name="sArray">需要拼接的数组</param>
         /// <param name="code">字符编码</param>
         /// <returns>拼接完成以后的字符串</returns>
         public  static  string  CreateLinkStringB(Dictionary< string ,  string > dicArray)
         {
             StringBuilder prestr =  new  StringBuilder();
             foreach  (KeyValuePair< string ,  string > temp  in  dicArray)
             {
                 prestr.Append(temp.Key +  "="  + temp.Value +  "&" );
             }
 
             //去掉最後一個&字符
             int  nLen = prestr.Length;
             prestr.Remove(nLen - 1, 1);
 
             return  prestr.ToString();
         }
         /// <summary>
         /// 把数组所有元素，按照“参数值”的模式用“&”字符拼接成字符串，并对参数值做urlencode
         /// </summary>
         /// <param name="sArray">需要拼接的数组</param>
         /// <param name="code">字符编码</param>
         /// <returns>拼接完成以后的字符串</returns>
         public  static  string  CreateLinkStringC(Dictionary< string ,  string > dicArray)
         {
             StringBuilder prestr =  new  StringBuilder();
             foreach  (KeyValuePair< string ,  string > temp  in  dicArray)
             {
                 prestr.Append(temp.Value);
             }
             return  prestr.ToString();
         }
         /// <summary>
         /// 多余字段用指定字符串代替
         /// </summary>
         /// <param name="MaxLength">字符串最大长度</param>
         /// <param name="ReplaceRemark">超出时代替的符号</param>
         /// <param name="value">要转换的字符串</param>
         /// <returns></returns>
         public  static  string  Overflow( int  MaxLength,  string  ReplaceRemark,  string  value)
         {
             if  (value.Length > MaxLength)
             {
                 return  value = value.Remove(MaxLength) + ReplaceRemark;
             }
             return  value;
         }
 
         /// <summary> 
         /// 每隔n个字符插入n个字符 
         /// </summary> 
         /// <param name="input">源字符串</param> 
         /// <param name="interval">间隔字符数</param> 
         /// <param name="value">待插入值</param> 
         /// <returns>返回新生成字符串</returns> 
         public  static  string  InsertFormat( string  input,  int  interval,  string  value)
         {
             for  ( int  i = interval; i < input.Length; i += interval + value.Length)
                 input = input.Insert(i, value);
             return  input;
         }
 
         /// <summary>
         /// 手机号码隐藏中间4位
         /// </summary>
         /// <param name="phone"></param>
         /// <returns></returns>
         public  static  string  HidePhone( string  phone)
         {
             return  Regex.Replace(phone,  "(\\d{3})\\d{4}(\\d{4})" ,  "$1****$2" );
         }
         /// <summary>
         /// 判断是否带http，flase=有，ture=没有
         /// </summary>
         /// <param name="url"></param>
         /// <returns></returns>
         public  static  bool  IsHttp( string  url)
         {
             string  reg =  @"^(http(s)?:\/\/)?(www\.)?[\w-]+(\.\w{2,4})?\.\w{2,4}?(\/)?$" ;
             Regex r =  new  Regex(reg);
             //给网址去所有空格
             string  urlStr = url.Trim();
             Match m = r.Match(urlStr);
 
             //判断是否带http://
             if  (!m.Success)
                 return  false ;
             return  true ;
         }
         #region 得到一周的周一和周日的日期
         /// <summary>
         /// 计算本周的周一日期
         /// </summary>
         /// <returns></returns>
         public  static  DateTime GetMondayDate()
         {
             return  GetMondayDate(DateTime.Now);
         }
         /// <summary>
         /// 计算本周周日的日期
         /// </summary>
         /// <returns></returns>
         public  static  DateTime GetSundayDate()
         {
             return  GetSundayDate(DateTime.Now);
         }
         /// <summary>
         /// 计算某日起始日期（礼拜一的日期）
         /// </summary>
         /// <param name="someDate">该周中任意一天</param>
         /// <returns>返回礼拜一日期，后面的具体时、分、秒和传入值相等</returns>
         public  static  DateTime GetMondayDate(DateTime someDate)
         {
             int  i = someDate.DayOfWeek - DayOfWeek.Monday;
             if  (i == -1) i = 6; // i值 > = 0 ，因为枚举原因，Sunday排在最前，此时Sunday-Monday=-1，必须+7=6。
             TimeSpan ts =  new  TimeSpan(i, 0, 0, 0);
             return  someDate.Subtract(ts);
         }
         /// <summary>
         /// 计算某日结束日期（礼拜日的日期）
         /// </summary>
         /// <param name="someDate">该周中任意一天</param>
         /// <returns>返回礼拜日日期，后面的具体时、分、秒和传入值相等</returns>
         public  static  DateTime GetSundayDate(DateTime someDate)
         {
             int  i = someDate.DayOfWeek - DayOfWeek.Sunday;
             if  (i != 0) i = 7 - i; // 因为枚举原因，Sunday排在最前，相减间隔要被7减。
             TimeSpan ts =  new  TimeSpan(i, 0, 0, 0);
             return  someDate.Add(ts);
         }
         #endregion
     }
     public  class  ValidateCode
     {
         public  ValidateCode()
         {
         }
         /// <summary>
         /// 验证码的最大长度
         /// </summary>
         public  int  MaxLength
         {
             get  {  return  10; }
         }
         /// <summary>
         /// 验证码的最小长度
         /// </summary>
         public  int  MinLength
         {
             get  {  return  1; }
         }
         /// <summary>
         /// 生成验证码
         /// </summary>
         /// <param name="length">指定验证码的长度</param>
         /// <returns></returns>
         public  string  CreateValidateCode( int  length)
         {
             int [] randMembers =  new  int [length];
             int [] validateNums =  new  int [length];
             string  validateNumberStr =  "" ;
             //生成起始序列值
             int  seekSeek =  unchecked (( int )DateTime.Now.Ticks);
             Random seekRand =  new  Random(seekSeek);
             int  beginSeek = ( int )seekRand.Next(0, Int32.MaxValue - length * 10000);
             int [] seeks =  new  int [length];
             for  ( int  i = 0; i < length; i++)
             {
                 beginSeek += 10000;
                 seeks[i] = beginSeek;
             }
             //生成随机数字
             for  ( int  i = 0; i < length; i++)
             {
                 Random rand =  new  Random(seeks[i]);
                 int  pownum = 1 * ( int )Math.Pow(10, length);
                 randMembers[i] = rand.Next(pownum, Int32.MaxValue);
             }
             //抽取随机数字
             for  ( int  i = 0; i < length; i++)
             {
                 string  numStr = randMembers[i].ToString();
                 int  numLength = numStr.Length;
                 Random rand =  new  Random();
                 int  numPosition = rand.Next(0, numLength - 1);
                 validateNums[i] = Int32.Parse(numStr.Substring(numPosition, 1));
             }
             //生成验证码
             for  ( int  i = 0; i < length; i++)
             {
                 validateNumberStr += validateNums[i].ToString();
             }
             return  validateNumberStr;
         }
         /// <summary>
         /// 创建验证码的图片
         /// </summary>
         /// <param name="context">要输出到的page对象</param>
         /// <param name="validateNum">验证码</param>
         public  void  CreateValidateGraphic( string  validateCode, HttpContext context)
         {
             Bitmap image =  new  Bitmap(( int )Math.Ceiling(validateCode.Length * 12.0), 22);
             Graphics g = Graphics.FromImage(image);
             try
             {
                 //生成随机生成器
                 Random random =  new  Random();
                 //清空图片背景色
                 g.Clear(Color.White);
                 //画图片的干扰线
                 for  ( int  i = 0; i < 25; i++)
                 {
                     int  x1 = random.Next(image.Width);
                     int  x2 = random.Next(image.Width);
                     int  y1 = random.Next(image.Height);
                     int  y2 = random.Next(image.Height);
                     g.DrawLine( new  Pen(Color.Silver), x1, y1, x2, y2);
                 }
                 Font font =  new  Font( "Arial" , 12, (FontStyle.Bold | FontStyle.Italic));
                 LinearGradientBrush brush =  new  LinearGradientBrush( new  Rectangle(0, 0, image.Width, image.Height),
                  Color.Blue, Color.DarkRed, 1.2f,  true );
                 g.DrawString(validateCode, font, brush, 3, 2);
                 //画图片的前景干扰点
                 for  ( int  i = 0; i < 100; i++)
                 {
                     int  x = random.Next(image.Width);
                     int  y = random.Next(image.Height);
                     image.SetPixel(x, y, Color.FromArgb(random.Next()));
                 }
                 //画图片的边框线
                 g.DrawRectangle( new  Pen(Color.Silver), 0, 0, image.Width - 1, image.Height - 1);
                 //保存图片数据
                 MemoryStream stream =  new  MemoryStream();
                 image.Save(stream, ImageFormat.Jpeg);
                 //输出图片流
                 context.Response.Clear();
                 context.Response.ContentType =  "image/jpeg" ;
                 context.Response.BinaryWrite(stream.ToArray());
             }
             finally
             {
                 g.Dispose();
                 image.Dispose();
             }
         }
         /// <summary>
         /// 得到验证码图片的长度
         /// </summary>
         /// <param name="validateNumLength">验证码的长度</param>
         /// <returns></returns>
         public  static  int  GetImageWidth( int  validateNumLength)
         {
             return  ( int )(validateNumLength * 12.0);
         }
         /// <summary>
         /// 得到验证码的高度
         /// </summary>
         /// <returns></returns>
         public  static  double  GetImageHeight()
         {
             return  22.5;
         }
 
 
 
         //C# MVC 升级版
         /// <summary>
         /// 创建验证码的图片
         /// </summary>
         /// <param name="containsPage">要输出到的page对象</param>
         /// <param name="validateNum">验证码</param>
         public  byte [] CreateValidateGraphic( string  validateCode)
         {
             Bitmap image =  new  Bitmap(( int )Math.Ceiling(validateCode.Length * 12.0), 22);
             Graphics g = Graphics.FromImage(image);
             try
             {
                 //生成随机生成器
                 Random random =  new  Random();
                 //清空图片背景色
                 g.Clear(Color.White);
                 //画图片的干扰线
                 for  ( int  i = 0; i < 25; i++)
                 {
                     int  x1 = random.Next(image.Width);
                     int  x2 = random.Next(image.Width);
                     int  y1 = random.Next(image.Height);
                     int  y2 = random.Next(image.Height);
                     g.DrawLine( new  Pen(Color.Silver), x1, y1, x2, y2);
                 }
                 Font font =  new  Font( "Arial" , 12, (FontStyle.Bold | FontStyle.Italic));
                 LinearGradientBrush brush =  new  LinearGradientBrush( new  Rectangle(0, 0, image.Width, image.Height),
                  Color.Blue, Color.DarkRed, 1.2f,  true );
                 g.DrawString(validateCode, font, brush, 3, 2);
                 //画图片的前景干扰点
                 for  ( int  i = 0; i < 100; i++)
                 {
                     int  x = random.Next(image.Width);
                     int  y = random.Next(image.Height);
                     image.SetPixel(x, y, Color.FromArgb(random.Next()));
                 }
                 //画图片的边框线
                 g.DrawRectangle( new  Pen(Color.Silver), 0, 0, image.Width - 1, image.Height - 1);
                 //保存图片数据
                 MemoryStream stream =  new  MemoryStream();
                 image.Save(stream, ImageFormat.Jpeg);
                 //输出图片流
                 return  stream.ToArray();
             }
             finally
             {
                 g.Dispose();
                 image.Dispose();
             }
         }
     }
}

猜你喜欢

转载自www.cnblogs.com/wangsir1992/p/9290413.html
今日推荐
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
周排行
[编程题]学英语
[codeforces 1288A] Deadline 约数+模
Python的web开发
Docker在Centos 7上的部署
python编码
解决Ubuntu16.04 fatal error: json/json.h: No such file or directory
mysql并发插入
rest接口如何适应jsonp的方案
linux 终端上网设置
高数——等号两边同时求导、积分的解释
每日归档
更多
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022