字符串操作助手类

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
    }
}