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 Ant.Common
{
public class StringHelper
{
#region 删除HTML标记
/// <summary>
/// 删除HTML标记
/// </summary>
/// <param name="htmlString">带有样式的字符串</param>
/// <returns></returns>
public static string RemoveHtmlFormat(string htmlString)
{
return Regex.Replace(htmlString, "<[^>]+>", "");
}
#endregion
#region 截断字符串
/// <summary>
/// 截断字符串
/// </summary>
/// <param name="str">要截断的字符串</param>
/// <param name="length">长度</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 由数字组成
/// <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就是两个日期之间的差额
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 转全角的函数(SBC case)
///
/// 转全角的函数(SBC case)
///
/// 任意字符串
/// 全角字符串
///
///全角空格为12288，半角空格为32///其他字符半角(33-126)与全角(65281-65374)的对应关系是：均相差65248
///
public string ToSBC(string input)
{
//半角转全角：
char[] c = input.ToCharArray();
for (int i = 0; i < c.Length; i++)
{
if (c[i] == 32)
{
c[i] = (char)12288;
continue;
}
if (c[i] < 127)
c[i] = (char)(c[i] + 65248);
}
return new string(c);
}
#endregion
#region 转半角的函数(DBC case)
///
/// 转半角的函数(DBC case)
///
/// 任意字符串
/// 半角字符串
///
///全角空格为12288，半角空格为32
///其他字符半角(33-126)与全角(65281-65374)的对应关系是：均相差65248
///
public string ToDBC(string input)
{
char[] c = input.ToCharArray();
for (int i = 0; i < c.Length; i++)
{
if (c[i] == 12288)
{
c[i] = (char)32;
continue;
}
if (c[i] > 65280 && c[i] < 65375)
c[i] = (char)(c[i] - 65248);
}
return new string(c);
}
#endregion
#region Html 编码
/// <summary>
/// 对文本框中的字符进行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>
/// 对字符串进行HTML解码,解析为可为页面识别的代码
/// </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 用户名过滤
/// <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注入过滤
/// <summary>
///SQL注入过滤
/// </summary>
/// <param name="InText">要进行过滤的字符串</param>
/// <returns>如果参数存在不安全字符,则返回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串执行sql关键字过滤并返回
/// </summary>
/// <param name="str">要过滤的字符串</param>
/// <returns></returns>
public static string SqlFilter(string str)
{
return str.Replace("'", "").Replace("'", "").Replace("--", "").Replace("&", "").Replace("/*", "").Replace(";", "").Replace("%", "");
}
/// <summary>
/// 将指定的串列表执行sql关键字过滤并以[,]号分隔返回
/// </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控件中选中的项
/// <summary>
/// 获取CheckBoxList控件中选中的项的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控件中选中的项的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 根据提供的Id字符串，将列表中的项选中
/// <summary>
/// 根据提供的Id字符串，将列表中的项选中
/// </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)
{
//将密码字符串转化成字节数组
byte[] byteArray = GetByteArray(src);
//计算 MD5 密码
byteArray = (new MD5CryptoServiceProvider().ComputeHash(byteArray));
//将字节码转化成字符串并返回
return BitConverter.ToString(byteArray);
}
/// <summary>
/// 将指定串加密为不包含中杠的MD5值
/// </summary>
/// <param name="str">要加密的字符串</param>
/// <param name="isupper">返回值的大小写(true大写,false小写)</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 将字符串翻译成字节数组
/// <summary>
/// 将字符串翻译成字节数组
/// </summary>
/// <param name="src">字符串源串</param>
/// <returns>字节数组</returns>
private static byte[] GetByteArray(string src)
{
byte[] byteArray = new byte[src.Length];
for (int i = 0; i < src.Length; i++)
{
byteArray[i] = Convert.ToByte(src[i]);
}
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
{
//默认密钥向量
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 转换为中文星期
/// <summary>
/// 转换为中文星期
/// </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 执行CMD 命令
/// <summary>
/// 执行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[i].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>
/// 替换指定符串中的首个指定字符为新的字符
/// </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 生成随机字符串，格式：1q2w3e4r
/// <summary>
/// 生成随机字符串，格式：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
public static object GetRequestObject(string key)
{
return HttpContext.Current.Request[key];
}
}
}