生成隨機(jī)字符串，格式：1q2w3e4r

將操作符代碼轉(zhuǎn)換為SQL的操作符號(hào)

StringHelper幫助類庫(kù)源碼

using System;
using System.Collections.Generic;
using System.Text;
using System.Text.RegularExpressions;
using System.IO;
using System.IO.Compression;
using System.Web.UI.WebControls;
using System.Security.Cryptography;
using System.Diagnostics;
using System.Web;
using System.Collections;
  
namespace JsonsTeam.Common
{
    public class StringHelper
    {
        #region 刪除HTML標(biāo)記
        /// <summary>
        /// 刪除HTML標(biāo)記
        /// </summary>
        /// <param name="htmlString">帶有樣式的字符串</param>
        /// <returns></returns>
        public static string RemoveHtmlFormat(string htmlString)
        {
            return Regex.Replace(htmlString, "<[^>] >", "");
        }
        #endregion
  
        #region 截?cái)嘧址?        /// <summary>
        /// 截?cái)嘧址?        /// </summary>
        /// <param name="str">要截?cái)嗟淖址?lt;/param>
        /// <param name="length">長(zhǎng)度</param>
        /// <returns></returns>
        public static string CutString(string str, int length)
        {
            int i = 0, j = 0;
            foreach (char chr in str)
            {
                i  = 2;
                if (i > length)
                {
                    str = str.Substring(0, j - 1)   "...";
                    break;
                }
                j  ;
            }
            return str;
        }
        #endregion
  
        #region 生成唯一ID 由數(shù)字組成
  
        /// <summary>
        /// 生成唯一ID
        /// </summary>
        /// <returns></returns>
        public static string CreateIDCode()
        {
            DateTime Time1 = DateTime.Now.ToUniversalTime();
            DateTime Time2 = Convert.ToDateTime("1970-01-01");
            TimeSpan span = Time1 - Time2;   //span就是兩個(gè)日期之間的差額   
            string t = span.TotalMilliseconds.ToString("0");
  
            return t;
        }
        #endregion
  
        #region 壓縮與解壓字符串
  
        #region 壓縮字符串
        /// <summary>
        /// 壓縮字符串
        /// </summary>
        /// <param name="unCompressedString">要壓縮的字符串</param>
        /// <returns></returns>
        public static string ZipString(string unCompressedString)
        {
  
            byte[] bytData = System.Text.Encoding.UTF8.GetBytes(unCompressedString);
            MemoryStream ms = new MemoryStream();
            Stream s = new GZipStream(ms, CompressionMode.Compress);
            s.Write(bytData, 0, bytData.Length);
            s.Close();
            byte[] compressedData = (byte[])ms.ToArray();
            return System.Convert.ToBase64String(compressedData, 0, compressedData.Length);
        }
  
        #endregion
  
        #region 解壓字符串
        /// <summary>
        ///  解壓字符串
        /// </summary>
        /// <param name="unCompressedString">要解壓的字符串</param>
        /// <returns></returns>
        public static string UnzipString(string unCompressedString)
        {
            System.Text.StringBuilder uncompressedString = new System.Text.StringBuilder();
            byte[] writeData = new byte[4096];
  
            byte[] bytData = System.Convert.FromBase64String(unCompressedString);
            int totalLength = 0;
            int size = 0;
  
            Stream s = new GZipStream(new MemoryStream(bytData), CompressionMode.Decompress);
            while (true)
            {
                size = s.Read(writeData, 0, writeData.Length);
                if (size > 0)
                {
                    totalLength  = size;
                    uncompressedString.Append(System.Text.Encoding.UTF8.GetString(writeData, 0, size));
                }
                else
                {
                    break;
                }
            }
            s.Close();
            return uncompressedString.ToString();
        }
  
        #endregion
  
        #endregion
  
        #region 轉(zhuǎn)全角的函數(shù)(SBC case)
        /// 
        /// 轉(zhuǎn)全角的函數(shù)(SBC case)
        /// 
        /// 任意字符串
        /// 全角字符串
        ///
        ///全角空格為12288，半角空格為32///其他字符半角(33-126)與全角(65281-65374)的對(duì)應(yīng)關(guān)系是：均相差65248
        ///        
        public string ToSBC(string input)
        {
            //半角轉(zhuǎn)全角：
            char[] c = input.ToCharArray();
            for (int i = 0; i < c.Length; i  )
            {
                if (c == 32)
                {
                    c = (char)12288;
                    continue;
                }
                if (c < 127)
                    c = (char)(c   65248);
            }
            return new string(c);
        }
  
        #endregion
  
        #region 轉(zhuǎn)半角的函數(shù)(DBC case)
        /// 
        /// 轉(zhuǎn)半角的函數(shù)(DBC case)
        /// 
        /// 任意字符串
        /// 半角字符串
        ///
        ///全角空格為12288，半角空格為32
        ///其他字符半角(33-126)與全角(65281-65374)的對(duì)應(yīng)關(guān)系是：均相差65248
        ///
        public string ToDBC(string input)
        {
            char[] c = input.ToCharArray();
            for (int i = 0; i < c.Length; i  )
            {
                if (c == 12288)
                {
                    c = (char)32;
                    continue;
                }
                if (c > 65280 && c < 65375)
                    c = (char)(c - 65248);
            }
            return new string(c);
        }
        #endregion
  
        #region Html 編碼
  
        /// <summary>
        /// 對(duì)文本框中的字符進(jìn)行HTML編碼
        /// </summary>
        /// <param name="str">源字符串</param>
        /// <returns></returns>
        public static string HtmlEncode(string str)
        {
            str = str.Replace("&", "&");
            str = str.Replace("'", "''");
            str = str.Replace("\"", """);
            str = str.Replace(" ", " ");
            str = str.Replace("<", "<");
            str = str.Replace(">", ">");
            str = str.Replace("\n", "<br>");
            return str;
        }
  
        /// <summary>
        /// 對(duì)字符串進(jìn)行HTML解碼,解析為可為頁(yè)面識(shí)別的代碼
        /// </summary>
        /// <param name="str">要解碼的字符串</param>
        /// <returns></returns>
        public static string HtmlDecode(string str)
        {
            str = str.Replace("<br>", "\n");
            str = str.Replace(">", ">");
            str = str.Replace("<", "<");
            str = str.Replace(" ", " ");
            str = str.Replace(""", "\"");
            return str;
        }
  
        #endregion
  
        #region  用戶名過(guò)濾
        /// <summary>
        /// 
        /// </summary>
        /// <param name="userName"></param>
        /// <returns></returns>
        public static bool Filter(string userName)
        {
            if (IsExist(userName,"!")) return false;
            if (IsExist(userName, "！")) return false;
            if (IsExist(userName, "#")) return false;
            if (IsExist(userName, "&")) return false;
            if (IsExist(userName, "$")) return false;
            if (IsExist(userName, "*")) return false;
            if (IsExist(userName, ".")) return false;
            if (IsExist(userName, ",")) return false;
            if (IsExist(userName, ";")) return false;
            if (IsExist(userName, "'")) return false;
            if (IsExist(userName, "<")) return false;
            if (IsExist(userName, ">")) return false;
            return true;
        }
  
        public static bool IsExist(string userName, string filterStr)
        {
            if (userName.IndexOf(filterStr) > -1)
                return true;
            return false;
        }
        #endregion
  
        #region SQL注入過(guò)濾
        /// <summary>
        ///SQL注入過(guò)濾
        /// </summary>
        /// <param name="InText">要進(jìn)行過(guò)濾的字符串</param>
        /// <returns>如果參數(shù)存在不安全字符,則返回true</returns>
        public static bool SqlFilter2(string InText)
        {
            string word = "exec|insert|select|delete|update|chr|mid|master|or|truncate|char|declare|join";
            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;
        }
  
        /// <summary>
        /// 將指定的str串執(zhí)行sql關(guān)鍵字過(guò)濾并返回
        /// </summary>
        /// <param name="str">要過(guò)濾的字符串</param>
        /// <returns></returns>
        public static string SqlFilter(string str)
        {
            return str.Replace("'", "").Replace("'", "").Replace("--", "").Replace("&","").Replace("/*","").Replace(";","").Replace("%","");
        }
  
        /// <summary>
        /// 將指定的串列表執(zhí)行sql關(guān)鍵字過(guò)濾并以[,]號(hào)分隔返回
        /// </summary>
        /// <param name="strs"></param>
        /// <returns></returns>
        public static string SqlFilters(params string[] strs)
        {
            StringBuilder sb = new StringBuilder();
            foreach (string str in strs)
            {
                sb.Append(SqlFilter(str)   ",");
            }
            if (sb.Length > 0)
                return sb.ToString().TrimEnd(',');
            return "";
        }
  
        public static bool ProcessSqlStr(string Str)
        {
            bool ReturnValue = false;
            try
            {
                if (Str != "")
                {
                    string SqlStr = "'|insert|select*|and'|or'|insertinto|deletefrom|altertable|update|createtable|createview|dropview|createindex|dropindex|createprocedure|dropprocedure|createtrigger|droptrigger|createschema|dropschema|createdomain|alterdomain|dropdomain|);|select@|declare@|print@|char(|select";
                    string[] anySqlStr = SqlStr.Split('|');
                    foreach (string ss in anySqlStr)
                    {
                        if (Str.IndexOf(ss) >= 0)
                        {
                            ReturnValue = true;
                        }
                    }
                }
            }
            catch
            {
                ReturnValue = true;
            }
  
            return ReturnValue;
        }
  
         
        #endregion
  
        #region 獲取CheckBoxList控件中選中的項(xiàng)
        /// <summary>
        /// 獲取CheckBoxList控件中選中的項(xiàng)的value，字符串由,分隔
        /// </summary>
        /// <param name="chk">CheckBoxList 控件ID</param>
        /// <returns></returns>
        public static string GetCheckedItemValue(CheckBoxList chk)
        {
            string s = "";
            foreach (ListItem li in chk.Items)
            {
                if (li.Selected)
                    s  = li.Value   ",";
            }
            return s.TrimEnd(',');
        }
        /// <summary>
        /// 獲取CheckBoxList控件中選中的項(xiàng)的Text，字符串由,分隔
        /// </summary>
        /// <param name="chk">CheckBoxList 控件ID</param>
        /// <returns></returns>
        public static string GetCheckedItemText(CheckBoxList chk)
        {
            string s = "";
            foreach (ListItem li in chk.Items)
            {
                if (li.Selected)
                    s  = li.Text   ",";
            }
            return s.TrimEnd(',');
        }
        #endregion
  
        #region 根據(jù)提供的Id字符串，將列表中的項(xiàng)選中
        /// <summary>
        /// 根據(jù)提供的Id字符串，將列表中的項(xiàng)選中
        /// </summary>
        /// <param name="itemid">Id字符串，由,分隔</param>
        /// <param name="checkboxlist">CheckBoxList控件</param>
        public static void CheckItem(string itemid, CheckBoxList checkboxlist)
        {
            foreach (ListItem li in checkboxlist.Items)
            {
                if (itemid.IndexOf(li.Value) != -1)
                    li.Selected = true;
            }
        }
  
        #endregion
  
        #region 加密字符串 MD5
        #region 利用 MD5 加密算法加密字符串
        /// <summary>
        /// 利用 MD5 加密算法加密字符串
        /// </summary>
        /// <param name="src">字符串源串</param>
        /// <returns>返加MD5 加密后的字符串</returns>
        public static string ComputeMD5(string src)
        {
            //將密碼字符串轉(zhuǎn)化成字節(jié)數(shù)組
            byte[] byteArray = GetByteArray(src);
  
            //計(jì)算 MD5 密碼
            byteArray = (new MD5CryptoServiceProvider().ComputeHash(byteArray));
  
            //將字節(jié)碼轉(zhuǎn)化成字符串并返回
            return BitConverter.ToString(byteArray);
        }
  
        /// <summary>
        /// 將指定串加密為不包含中杠的MD5值
        /// </summary>
        /// <param name="str">要加密的字符串</param>
        /// <param name="isupper">返回值的大小寫(xiě)(true大寫(xiě),false小寫(xiě))</param>
        /// <returns></returns>
        public static string ComputeMD5(string str, bool isupper)
        {
            string md5str = ComputeMD5(str);
            if (isupper)
                return md5str.ToUpper();
            return md5str.ToLower();
        }
        #endregion
  
        #region 將字符串翻譯成字節(jié)數(shù)組
        /// <summary>
        /// 將字符串翻譯成字節(jié)數(shù)組
        /// </summary>
        /// <param name="src">字符串源串</param>
        /// <returns>字節(jié)數(shù)組</returns>
        private static byte[] GetByteArray(string src)
        {
            byte[] byteArray = new byte[src.Length];
  
            for (int i = 0; i < src.Length; i  )
            {
                byteArray = Convert.ToByte(src);
            }
  
            return byteArray;
        }
        #endregion
  
        #region MD5string
  
        public static string MD5string(string str)
        {
            return System.Web.Security.FormsAuthentication.HashPasswordForStoringInConfigFile(str, "MD5");
        }
  
        public static string MD5string(string str,bool isupper)
        {
            string md5string = MD5string(str);
            if (isupper)
                return md5string.ToUpper();
            else
                return md5string.ToLower();
        }
  
        #endregion
        #endregion
  
        #region SHA1 加密
        public string SHA1(string Source_String)
        {
            byte[] StrRes = Encoding.Default.GetBytes(Source_String);
            HashAlgorithm iSHA = new SHA1CryptoServiceProvider();
            StrRes = iSHA.ComputeHash(StrRes);
            StringBuilder EnText = new StringBuilder();
            foreach (byte iByte in StrRes)
            {
                EnText.AppendFormat("{0:x2}", iByte);
            }
            return EnText.ToString();
        }
        #endregion
  
        #region DES加密字符串
        /// <summary>
        /// DES加密字符串
        /// </summary>
        /// <param name="encryptString">待加密的字符串</param>
        /// <param name="encryptKey">加密密鑰,要求為8位</param>
        /// <returns>加密成功返回加密后的字符串，失敗返回源串</returns>
        public static string EncryptDES(string encryptString,string key)
        {
            try
            {
                byte[] rgbKey = Encoding.UTF8.GetBytes(key);
                byte[] rgbIV = { 0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF };
                byte[] inputByteArray = Encoding.UTF8.GetBytes(encryptString);
                DESCryptoServiceProvider dCSP = new DESCryptoServiceProvider();
                MemoryStream mStream = new MemoryStream();
                CryptoStream cStream = new CryptoStream(mStream, dCSP.CreateEncryptor(rgbKey, rgbIV), CryptoStreamMode.Write);
                cStream.Write(inputByteArray, 0, inputByteArray.Length);
                cStream.FlushFinalBlock();
                return Convert.ToBase64String(mStream.ToArray());
            }
            catch
            {
                return encryptString;
            }
        }
        #endregion
  
        #region DES解密字符串
        /// <summary>
        /// DES解密字符串
        /// </summary>
        /// <param name="decryptString">待解密的字符串</param>
        /// <param name="key">解密密鑰，要求8位</param>
        /// <returns></returns>
        public static string DecryptDES(string decryptString,string key)
        {
            try
            {
                //默認(rèn)密鑰向量
                byte[] Keys = { 0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF };
                byte[] rgbKey = Encoding.UTF8.GetBytes(key);
                byte[] rgbIV = Keys;
                byte[] inputByteArray = Convert.FromBase64String(decryptString);
                DESCryptoServiceProvider DCSP = new DESCryptoServiceProvider();
                MemoryStream mStream = new MemoryStream();
                CryptoStream cStream = new CryptoStream(mStream, DCSP.CreateDecryptor(rgbKey, rgbIV), CryptoStreamMode.Write);
                cStream.Write(inputByteArray, 0, inputByteArray.Length);
                cStream.FlushFinalBlock();
                return Encoding.UTF8.GetString(mStream.ToArray());
            }
            catch
            {
                return decryptString;
            }
        }
  
        #endregion
  
        #region AES 加密 解密
         
         
  
        /// <summary>
        /// AES加密
        /// </summary>
        /// <param name="str">要加密字符串</param>
        /// <returns>返回加密后字符串</returns>
        public static String EncryptAES(String str,string aeskey)
        {
            Byte[] keyArray = System.Text.UTF8Encoding.UTF8.GetBytes(aeskey);
            Byte[] toEncryptArray = System.Text.UTF8Encoding.UTF8.GetBytes(str);
  
            System.Security.Cryptography.RijndaelManaged rDel = new System.Security.Cryptography.RijndaelManaged();
            rDel.Key = keyArray;
            rDel.Mode = System.Security.Cryptography.CipherMode.ECB;
            rDel.Padding = System.Security.Cryptography.PaddingMode.PKCS7;
  
            System.Security.Cryptography.ICryptoTransform cTransform = rDel.CreateEncryptor();
            Byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
  
            return Convert.ToBase64String(resultArray, 0, resultArray.Length);
        }
  
  
  
        /// <summary>
        /// AES解密
        /// </summary>
        /// <param name="str">要解密字符串</param>
        /// <returns>返回解密后字符串</returns>
        public static String DecryptAES(String str, string aeskey)
        {
            Byte[] keyArray = System.Text.UTF8Encoding.UTF8.GetBytes(aeskey);
            Byte[] toEncryptArray = Convert.FromBase64String(str);
  
            System.Security.Cryptography.RijndaelManaged rDel = new System.Security.Cryptography.RijndaelManaged();
            rDel.Key = keyArray;
            rDel.Mode = System.Security.Cryptography.CipherMode.ECB;
            rDel.Padding = System.Security.Cryptography.PaddingMode.PKCS7;
  
            System.Security.Cryptography.ICryptoTransform cTransform = rDel.CreateDecryptor();
            Byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
  
            return System.Text.UTF8Encoding.UTF8.GetString(resultArray);
        }
  
 #endregion
  
        #region  base64 字符串編碼
        /// <summary>
        /// base64 字符串編碼
        /// </summary>
        /// <param name="str">要編碼的字符串</param>
        /// <returns></returns>
        public static string ToBase64(string str)
        {
            byte[] data = System.Text.ASCIIEncoding.ASCII.GetBytes(str);
            return Convert.ToBase64String(data); 
        }
  
        /// <summary>
        /// base 64 字符串解碼
        /// </summary>
        /// <param name="base64str">要解碼的字符串</param>
        /// <returns></returns>
        public static string UnBase64(string base64str)
        {
            byte[] data = Convert.FromBase64String(base64str);
            return System.Text.ASCIIEncoding.ASCII.GetString(data); 
        }
  
  
        #endregion
  
        #region 轉(zhuǎn)換為中文星期
        /// <summary>
        /// 轉(zhuǎn)換為中文星期
        /// </summary>
        /// <param name="dayfweek">英文星期</param>
        /// <returns></returns>
        public static string ConvertWeekDayToCn(DayOfWeek dayfweek)
        {
            switch (dayfweek)
            {
                case DayOfWeek.Sunday:
                    return "星期日";
                case DayOfWeek.Monday:
                    return "星期一";
                case DayOfWeek.Tuesday:
                    return "星期二";
                case DayOfWeek.Wednesday:
                    return "星期三";
                case DayOfWeek.Thursday:
                    return "星期四";
                case DayOfWeek.Friday:
                    return "星期五";
                case DayOfWeek.Saturday:
                    return "星期六";
                default:
                    return "";
            }
        }
  
        #endregion
  
        #region 執(zhí)行CMD 命令
        /// <summary>
        /// 執(zhí)行CMD 命令
        /// </summary>
        /// <param name="strCommand">命令串</param>
        /// <returns></returns>
        public static string RunCommand(string strCommand)
        {
            Process process = new Process();
            process.StartInfo.FileName = "CMD.exe";
            process.StartInfo.UseShellExecute = false;
            process.StartInfo.RedirectStandardInput = true;
            process.StartInfo.RedirectStandardOutput = true;
            process.StartInfo.RedirectStandardError = true;
            process.StartInfo.CreateNoWindow = true;
            process.Start();
            process.StandardInput.WriteLine(strCommand);
            process.StandardInput.WriteLine("exit");
            string str = process.StandardOutput.ReadToEnd();
            process.Close();
            return str;
        }
        #endregion
  
         
        public static string Escape(string s)
        {
            StringBuilder builder = new StringBuilder();
            byte[] bytes = Encoding.Unicode.GetBytes(s);
            for (int i = 0; i < bytes.Length; i  = 2)
            {
                builder.Append("%u");
                builder.Append(bytes[i   1].ToString("X2"));
                builder.Append(bytes.ToString("X2"));
            }
            return builder.ToString();
        }
  
        public static string ReplaceHtml(string str)
        {
            if (str == null || str.Length==0)
                return "";
            str = str.Replace("<", "<");
            str = str.Replace(">", ">");
            str = str.Replace("\n", "");
            str = str.Replace("\r", "");
            return str; 
        }
  
        public static string ReplaceEnter(string str)
        {
            if (str == null || str.Length == 0)
                return "";
              
            str = str.Replace("\n", "");
            str = str.Replace("\r", "");
            return str;
        }
  
        /// <summary>
        /// 替換指定符串中的首個(gè)指定字符為新的字符
        /// </summary>
        /// <param name="sourcestr">要修改的字符串</param>
        /// <param name="oldstr">被替換的字符串</param>
        /// <param name="newstr">替換字符串 </param>
        /// <returns></returns>
        public static string ReplaceFirst(string sourcestr,string oldstr, string newstr)
        {
            Regex reg = new Regex(oldstr);
            if (reg.IsMatch(sourcestr))
            {
                sourcestr = reg.Replace(sourcestr, newstr, 1);
            }
            return sourcestr;
        }
  
        #region 生成隨機(jī)字符串，格式：1q2w3e4r
        /// <summary>
        /// 生成隨機(jī)字符串，格式：1q2w3e4r
        /// </summary>
        /// <returns></returns>
        public static string BuildPassword()
        {
            Random random = new Random();
            List<int> ints = new List<int>();
            for (int i = 0; i < 4; i  )
            {
                ints.Add(random.Next(9));
            }
  
            List<string> strs = new List<string>();
  
            //string CodeSerial = "a,b,c,d,e,f,g,h,i,j,k,m,n,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,J,K,L,M,N,P,Q,R,S,T,U,V,W,X,Y,Z";
            string CodeSerial = "a,b,c,d,e,f,g,h,i,j,k,m,n,p,q,r,s,t,u,v,w,x,y,z";
  
            string[] arr = CodeSerial.Split(',');
  
            int randValue = -1;
            Random rand = new Random(unchecked((int)DateTime.Now.Ticks));
  
            for (int i = 0; i < 4; i  )
            {
                randValue = rand.Next(0, arr.Length - 1);
  
                strs.Add(arr[randValue]);
            }
  
            string passwd = "";
  
            for (int k = 0; k < 4; k  )
            {
                passwd  = ints[k].ToString()   strs[k];
            }
  
            return passwd;
        }
        #endregion
       /// <summary>
        /// 將操作符代碼轉(zhuǎn)換為SQL的操作符號(hào)
        /// </summary>
        /// <param name="op"></param>
        /// <returns></returns>
        private static string GetOperatorQueryText(string op)
        {
            switch (op.ToLower())
            {
                case "eq": return " = ";
                case "gt": return " > ";
                case "ge": return " >= ";
                case "nu": return " IS NULL ";
                case "nn": return " IS NOT NULL ";
                case "lt": return " < ";
                case "le": return " <= ";
                case "cn": return " like ";
                case "bw": return " like ";
                case "ew": return " like ";
                case "ne": return " <> ";
                case "in": return " IN ";
                case "ni": return " NOT IN ";
                default: return " = ";
            }
        }
  
        public static object GetRequestObject(string key)
        {
            return HttpContext.Current.Request[key];
        }
    }
}

原文鏈接：StringHelper字符串處理幫助類庫(kù)大全<二>