using System;
using System.Collections;
using System.Text;
using System.Text.RegularExpressions;
namespace Commons.Helpers
{
/// <summary>
/// 字符串操作助手类
/// </summary>
public class StringHelper
{
#region 获取处理好的行数据
public static SortedList GetSortedList(string line)
{
string src = line.Replace("\"\"", "'");
MatchCollection col = Regex.Matches(src, ",\"([^\"]+)\",", RegexOptions.ExplicitCapture);
SortedList sl = new SortedList();
IEnumerator ie = col.GetEnumerator();
while (ie.MoveNext())
{
string patn = ie.Current.ToString();
int key = src.Substring(0, src.IndexOf(patn)).Split(',').Length;
if (!sl.ContainsKey(key))
{
sl.Add(key, patn.Trim(new[] { ',', '"' }).Replace("'", "\""));
src = src.Replace(patn, ",,");
}
}
string[] arr = src.Split(',');
for (int i = 0; i < arr.Length; i++)
{
if (!sl.ContainsKey(i))
{
sl.Add(i, arr[i]);
}
}
return sl;
}
#endregion
#region 字符串左补零
/// <summary>
/// 字符串左补零
/// </summary>
/// <param name="inStr">原字符串</param>
/// <param name="len">补零后字符串的总长</param>
/// <returns></returns>
public static string StringPadLeftZero(string inStr, int len)
{
string outStr = inStr;
if (inStr.Length < len)
{
outStr = inStr.PadLeft(len, '0');
}
return outStr;
}
#endregion
#region 转换中文的逗号并去掉最后的逗号
/// <summary>
/// 转换中文的逗号并去掉最后的逗号
/// </summary>
/// <param name="strList">逗号串起来的字符串</param>
/// <returns>最后没用逗号的字符串</returns>
public static string DeleteLastComma(string strList)
{
//判断是否为空
if (!String.IsNullOrEmpty(strList))
{
//转换中文的逗号
strList = Regex.Replace(strList, ",", ",");
//判断最后一位是否逗号
while (strList.IndexOf(',') == 0 || strList.LastIndexOf(',') == strList.Length - 1)
{
strList = strList.IndexOf(',') == 0 ? strList.Substring(1) : strList;
strList = strList.LastIndexOf(',') == strList.Length - 1 ? strList.Substring(0, strList.Length - 1) : strList;
}
}
return strList;
}
#endregion
#region 过滤特殊符号
/// <summary>
/// 过滤特殊符号
/// </summary>
/// <param name="text">字符串</param>
/// <returns>返回特殊符号</returns>
public static string FilerSymbol(string text)
{
StringBuilder sb = new StringBuilder();
string symbol = "@,#,$,*,_,&,^,|,\\,/";
string[] symbolGroup = symbol.Split(',');
foreach (string t in symbolGroup)
{
int exist = text.IndexOf(t);
//判断是否存在特殊符号
if (exist != -1)
{
sb.Append(t);
sb.Append(",");
}
}
string result = DeleteLastComma(sb.ToString());
return result;
}
#endregion
#region 自定义的替换字符串函数
/// <summary>
/// 自定义的替换字符串函数
/// </summary>
public static string ReplaceSymbol(string text)
{
string symbol = "@,#,$,*,~,&,^,|,\\,/,%,(,),+,{,},:,;,.,<,>,?,\",',!,[,],`,€";
string[] symbolGroup = symbol.Split(',');
foreach (string t in symbolGroup)
{
text = text.Replace(t, "_");
}
return text.Replace(" ", "").Replace(",", "");
}
#endregion
#region 合并字符
/// <summary>
/// 合并字符
/// </summary>
/// <param name="source">要合并的源字符串</param>
/// <param name="target">要被合并到的目的字符串</param>
/// <returns>合并到的目的字符串</returns>
public static string MergeString(string source, string target)
{
return MergeString(source, target, ",");
}
/// <summary>
/// 合并字符
/// </summary>
/// <param name="source">要合并的源字符串</param>
/// <param name="target">要被合并到的目的字符串</param>
/// <param name="mergechar">合并符</param>
/// <returns>并到字符串</returns>
public static string MergeString(string source, string target, string mergechar)
{
if (String.IsNullOrEmpty(target))
{
target = source;
}
else
{
target += mergechar + source;
}
return target;
}
#endregion
#region 删除最后一个字符
/// <summary>
/// 删除最后一个字符
/// </summary>
/// <param name="str">字符串</param>
/// <returns></returns>
public static string ClearLastChar(string str)
{
if (str == "")
{
return "";
}
return str.Substring(0, str.Length - 1);
}
#endregion
#region 替换回车换行符为html换行符
/// <summary>
/// 替换回车换行符为html换行符
/// </summary>
/// <param name="str">字符串</param>
/// <returns></returns>
public static string StrFormat(string str)
{
string str2;
if (str == null)
{
str2 = "";
}
else
{
str = str.Replace("\r\n", "<br />");
str = str.Replace("\n", "<br />");
str2 = str;
}
return str2;
}
#endregion
#region 删除字符串尾部的回车/换行/空格
/// <summary>
/// 删除字符串尾部的回车/换行/空格
/// </summary>
/// <param name="str">字符串</param>
/// <returns></returns>
public static string RTrim(string str)
{
for (int i = str.Length; i >= 0; i--)
{
if (str[i].Equals(" ") || str[i].Equals("\r") || str[i].Equals("\n"))
{
return str.Remove(i, 1);
}
}
return str;
}
#endregion
#region 生成指定数量的html空格符号
/// <summary>
/// 生成指定数量的html空格符号
/// </summary>
/// <param name="spacesCount">空格数量</param>
/// <returns></returns>
public static string GetSpacesString(int spacesCount)
{
StringBuilder sb = new StringBuilder();
for (int i = 0; i < spacesCount; i++)
{
sb.Append(" ");
}
return sb.ToString();
}
#endregion
#region 从字符串的指定位置截取指定长度的子字符串
/// <summary>
/// 从字符串的指定位置截取指定长度的子字符串
/// </summary>
/// <param name="str">原字符串</param>
/// <param name="startIndex">子字符串的起始位置</param>
/// <param name="length">子字符串的长度</param>
/// <returns>子字符串</returns>
public static string CutString(string str, int startIndex, int length)
{
if (startIndex >= 0)
{
if (length < 0)
{
length = length * -1;
if (startIndex - length < 0)
{
length = startIndex;
startIndex = 0;
}
else
{
startIndex = startIndex - length;
}
}
if (startIndex > str.Length)
{
return "";
}
}
else
{
if (length < 0)
{
return "";
}
if (length + startIndex > 0)
{
length = length + startIndex;
startIndex = 0;
}
else
{
return "";
}
}
if (str.Length - startIndex < length)
{
length = str.Length - startIndex;
}
return str.Substring(startIndex, length);
}
#endregion
#region 从字符串的指定位置开始截取到字符串结尾的了符串
/// <summary>
/// 从字符串的指定位置开始截取到字符串结尾的了符串
/// </summary>
/// <param name="str">原字符串</param>
/// <param name="startIndex">子字符串的起始位置</param>
/// <returns>子字符串</returns>
public static string CutString(string str, int startIndex)
{
return CutString(str, startIndex, str.Length);
}
#endregion
#region 返回字符串真实长度, 1个汉字长度为2
/// <summary>
/// 返回字符串真实长度, 1个汉字长度为2
/// </summary>
/// <param name="str">字符串</param>
/// <returns>字符长度</returns>
public static int GetStringLength(string str)
{
return Encoding.Default.GetBytes(str).Length;
}
#endregion
#region 字符串如果操过指定长度则将超出的部分用指定字符串代替
/// <summary>
/// 字符串如果操过指定长度则将超出的部分用指定字符串代替
/// </summary>
/// <param name="p_SrcString">要检查的字符串</param>
/// <param name="p_Length">指定长度</param>
/// <param name="p_TailString">用于替换的字符串</param>
/// <returns>截取后的字符串</returns>
public static string GetSubString(string p_SrcString, int p_Length, string p_TailString)
{
return GetSubString(p_SrcString, 0, p_Length, p_TailString);
}
#endregion
#region 取指定长度的字符串
/// <summary>
/// 取指定长度的字符串
/// </summary>
/// <param name="p_SrcString">要检查的字符串</param>
/// <param name="p_StartIndex">起始位置</param>
/// <param name="p_Length">指定长度</param>
/// <param name="p_TailString">用于替换的字符串</param>
/// <returns>截取后的字符串</returns>
public static string GetSubString(string p_SrcString, int p_StartIndex, int p_Length, string p_TailString)
{
string myResult = p_SrcString;
Byte[] bComments = Encoding.UTF8.GetBytes(p_SrcString);
foreach (char c in Encoding.UTF8.GetChars(bComments))
{
//当是日文或韩文时(注:中文的范围:\u4e00 - \u9fa5, 日文在\u0800 - \u4e00, 韩文为\xAC00-\xD7A3)
if ((c > '\u0800' && c < '\u4e00') || (c > '\xAC00' && c < '\xD7A3'))
{
//if (System.Text.RegularExpressions.Regex.IsMatch(p_SrcString, "[\u0800-\u4e00]+") || System.Text.RegularExpressions.Regex.IsMatch(p_SrcString, "[\xAC00-\xD7A3]+"))
//当截取的起始位置超出字段串长度时
if (p_StartIndex >= p_SrcString.Length)
{
return "";
}
return p_SrcString.Substring(p_StartIndex,
((p_Length + p_StartIndex) > p_SrcString.Length) ? (p_SrcString.Length - p_StartIndex) : p_Length);
}
}
if (p_Length >= 0)
{
byte[] bsSrcString = Encoding.Default.GetBytes(p_SrcString);
//当字符串长度大于起始位置
if (bsSrcString.Length > p_StartIndex)
{
int p_EndIndex = bsSrcString.Length;
//当要截取的长度在字符串的有效长度范围内
if (bsSrcString.Length > (p_StartIndex + p_Length))
{
p_EndIndex = p_Length + p_StartIndex;
}
else
{ //当不在有效范围内时,只取到字符串的结尾
p_Length = bsSrcString.Length - p_StartIndex;
p_TailString = "";
}
int nRealLength = p_Length;
int[] anResultFlag = new int[p_Length];
int nFlag = 0;
for (int i = p_StartIndex; i < p_EndIndex; i++)
{
if (bsSrcString[i] > 127)
{
nFlag++;
if (nFlag == 3)
{
nFlag = 1;
}
}
else
{
nFlag = 0;
}
anResultFlag[i] = nFlag;
}
if ((bsSrcString[p_EndIndex - 1] > 127) && (anResultFlag[p_Length - 1] == 1))
{
nRealLength = p_Length + 1;
}
byte[] bsResult = new byte[nRealLength];
Array.Copy(bsSrcString, p_StartIndex, bsResult, 0, nRealLength);
myResult = Encoding.Default.GetString(bsResult);
myResult = myResult + p_TailString;
}
}
return myResult;
}
#endregion
#region 取指定长度的字符串 中文字符计算加2
public static string GetUnicodeSubString(string str, int len, string p_TailString)
{
string result = String.Empty;// 最终返回的结果
int byteLen = Encoding.Default.GetByteCount(str);// 单字节字符长度
int charLen = str.Length;// 把字符平等对待时的字符串长度
int byteCount = 0;// 记录读取进度
int pos = 0;// 记录截取位置
if (byteLen > len)
{
for (int i = 0; i < charLen; i++)
{
if (Convert.ToInt32(str.ToCharArray()[i]) > 255)// 按中文字符计算加2
byteCount += 2;
else// 按英文字符计算加1
byteCount += 1;
if (byteCount > len)// 超出时只记下上一个有效位置
{
pos = i;
break;
}
if (byteCount == len)// 记下当前位置
{
pos = i + 1;
break;
}
}
if (pos >= 0)
{
result = str.Substring(0, pos) + p_TailString;
}
}
else
{
result = str;
}
return result;
}
#endregion
#region 自定义的替换字符串函数
/// <summary>
/// 自定义的替换字符串函数
/// </summary>
public static string ReplaceString(string SourceString, string SearchString, string ReplaceString, bool IsCaseInsensetive)
{
return Regex.Replace(SourceString, Regex.Escape(SearchString), ReplaceString, IsCaseInsensetive ? RegexOptions.IgnoreCase : RegexOptions.None);
}
#endregion
#region 过滤危险脚本
public static string WipeScript(string html)
{
Regex regex1 = new Regex(@"<script[\s\s]+</script *>", RegexOptions.IgnoreCase);
Regex regex2 = new Regex(@" href *= *[\s\s]*script *:", RegexOptions.IgnoreCase);
Regex regex3 = new Regex(@" on[\s\s]*=", RegexOptions.IgnoreCase);
Regex regex4 = new Regex(@"<iframe[\s\s]+</iframe *>", RegexOptions.IgnoreCase);
Regex regex5 = new Regex(@"<frameset[\s\s]+</frameset *>", RegexOptions.IgnoreCase);
html = regex1.Replace(html, ""); //过滤<script></script>标记
html = regex2.Replace(html, ""); //过滤href=javascript: (<a>) 属性
html = regex3.Replace(html, " _disibledevent="); //过滤其它控件的on...事件
html = regex4.Replace(html, ""); //过滤iframe
html = regex5.Replace(html, ""); //过滤frameset
return html;
}
#endregion
#region 分割字符串
/// <summary>
/// 分割字符串
/// </summary>
/// <param name="strContent">被分割的字符串</param>
/// <param name="strSplit">分隔符</param>
/// <returns></returns>
public static string[] SplitString(string strContent, string strSplit)
{
if (!String.IsNullOrEmpty(strContent))
{
if (strContent.IndexOf(strSplit) < 0)
{
string[] tmp = { strContent };
return tmp;
}
return Regex.Split(strContent, Regex.Escape(strSplit), RegexOptions.IgnoreCase);
}
return new string[] { };
}
/// <summary>
/// 分割字符串
/// </summary>
/// <param name="strContent">被分割的字符串</param>
/// <param name="strSplit">分隔符</param>
/// <param name="count">数组的数量</param>
/// <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++)
{
result[i] = i < splited.Length ? splited[i] : String.Empty;
}
return result;
}
/// <summary>
/// 分割字符串
/// </summary>
/// <param name="strContent">被分割的字符串</param>
/// <param name="strSplit">分割符</param>
/// <param name="ignoreRepeatItem">忽略重复项</param>
/// <param name="maxElementLength">单个元素最大长度</param>
/// <returns></returns>
public static string[] SplitString(string strContent, string strSplit, bool ignoreRepeatItem, int maxElementLength)
{
string[] result = SplitString(strContent, strSplit);
return ignoreRepeatItem ? ArrayHelper.DistinctStringArray(result, maxElementLength) : result;
}
public static string[] SplitString(string strContent, string strSplit, bool ignoreRepeatItem, int minElementLength, int maxElementLength)
{
string[] result = SplitString(strContent, strSplit);
if (ignoreRepeatItem)
{
result = ArrayHelper.DistinctStringArray(result);
}
return ArrayHelper.PadStringArray(result, minElementLength, maxElementLength);
}
/// <summary>
/// 分割字符串
/// </summary>
/// <param name="strContent">被分割的字符串</param>
/// <param name="strSplit">分割符</param>
/// <param name="ignoreRepeatItem">忽略重复项</param>
/// <returns></returns>
public static string[] SplitString(string strContent, string strSplit, bool ignoreRepeatItem)
{
return SplitString(strContent, strSplit, ignoreRepeatItem, 0);
}
#endregion
#region 字符串重复
/// <summary>
/// 字符串重复N倍
/// </summary>
/// <param name="str"></param>
/// <param name="n"></param>
/// <returns></returns>
public static string RepeatString(string str, int n)
{
char[] arr = str.ToCharArray();
char[] arrDest = new char[arr.Length * n];
for (int i = 0; i < n; i++)
{
Buffer.BlockCopy(arr, 0, arrDest, i * arr.Length * 2, arr.Length * 2);
}
return new string(arrDest);
}
#endregion
#region Base64解码
/// <summary>
/// Base64解码
/// </summary>
/// <param name="str"></param>
/// <returns></returns>
public static string Base64_Decode(string str)
{
byte[] bytes = Convert.FromBase64String(str);
return Encoding.UTF8.GetString(bytes);
}
#endregion
#region Base64编码
/// <summary>
/// Base64编码
/// </summary>
/// <param name="str"></param>
/// <returns></returns>
public static string Base64_Encode(string str)
{
return Convert.ToBase64String(Encoding.UTF8.GetBytes(str));
}
#endregion
#region 清理无效XML字符
/// <summary>
/// 清理无效XML字符
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public static string CleanInvalidCharsForXML(string input)
{
if (String.IsNullOrEmpty(input))
{
return input;
}
StringBuilder builder = new StringBuilder();
char[] chArray = input.ToCharArray();
foreach (char t in chArray)
{
int num2 = Convert.ToInt32(t);
if ((((num2 < 0) || (num2 > 8)) && ((num2 < 11) || (num2 > 12))) && ((num2 < 14) || (num2 > 0x1f)))
{
builder.Append(t);
}
}
return builder.ToString();
}
#endregion
#region 防SQL注入
/// <summary>
/// 防SQL注入
/// </summary>
/// <param name="sql"></param>
/// <returns></returns>
public static string StripSQLInjection(string sql)
{
if (!String.IsNullOrEmpty(sql))
{
string pattern = @"(\%27)|(\')|(\-\-)";
string str2 = @"((\%27)|(\'))\s*((\%6F)|o|(\%4F))((\%72)|r|(\%52))";
string str3 = @"\s+exec(\s|\+)+(s|x)p\w+";
sql = Regex.Replace(sql, pattern, String.Empty, RegexOptions.IgnoreCase);
sql = Regex.Replace(sql, str2, String.Empty, RegexOptions.IgnoreCase);
sql = Regex.Replace(sql, str3, String.Empty, RegexOptions.IgnoreCase);
}
return sql;
}
#endregion
#region 截取字符
public static string Trim(string stringTrim, int maxLength)
{
return Trim(stringTrim, maxLength, "...");
}
public static string Trim(string rawString, int maxLength, string appendString)
{
if (String.IsNullOrEmpty(rawString) || (rawString.Length <= maxLength))
{
return rawString;
}
if (Encoding.UTF8.GetBytes(rawString).Length <= (maxLength * 2))
{
return rawString;
}
int length = Encoding.UTF8.GetBytes(appendString).Length;
StringBuilder builder = new StringBuilder();
int num3 = 0;
foreach (char ch in rawString)
{
builder.Append(ch);
num3 += Encoding.Default.GetBytes(new[] { ch }).Length;
if (num3 >= ((maxLength * 2) - length))
{
break;
}
}
return (builder + appendString);
}
#endregion
#region 生成时间截
public static string GenerateTimeStamp()
{
TimeSpan ts = DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, 0);
return Convert.ToInt64(ts.TotalSeconds).ToString();
}
#endregion
#region 替换sql语句中的有问题符号
/// <summary>
/// 替换sql语句中的有问题符号
/// </summary>
public static string ChkSQL(string str)
{
return (str == null) ? "" : str.Replace("'", "''");
}
#endregion
#region 替换手机号和邮箱中间几位
/// <summary>
/// 替换手机号中间四位为*
/// </summary>
/// <param name="phoneNo"></param>
/// <returns></returns>
public static string ReturnPhoneNO(string phoneNo)
{
Regex re = new Regex(@"(\d{3})(\d{4})(\d{4})", RegexOptions.None);
phoneNo = re.Replace(phoneNo, "$1****$3");
return phoneNo;
}
/// <summary>
/// 替换邮箱中间几位为*号
/// </summary>
/// <param name="Email"></param>
/// <returns></returns>
public static string ReturnEmail(string Email)
{
Regex re = new Regex(@"\w{3}(?=@\w+?.\S+)", RegexOptions.None);
Email = re.Replace(Email, "****");
return Email;
}
#endregion
}
}
字符串操作助手类
最新推荐文章于 2024-09-15 07:28:50 发布