通用类 StringHelper 字符串操作方法

/// <summary>
    /// 字符串操作方法
    /// </summary>
    public class StringHelper
    {
        #region SQL 特殊字符过滤,防SQL注入
        /// <summary>
        /// SQL 特殊字符过滤,防SQL注入
        /// </summary>
        /// <param name="contents">检查的SQL语句</param>
        /// <returns></returns>
        public static string SqlFilter( string contents )
        {
            if (!string.IsNullOrEmpty(contents))
            {
                contents = Regex.Replace(contents, " exec | insert | select | delete | update | master | truncate | declare ", "", RegexOptions.IgnoreCase);
                contents = contents.Replace("'", "''");
            }
            return contents;
        }

        #endregion
                
        #region 替换标记内的内容
        /// <summary>
        /// 替换标记内的内容
        /// </summary>
        /// <param name="beginTag">开始标记</param>
        /// <param name="endTag">结束标记</param>
        /// <param name="contents">原始内容</param>
        /// <param name="newContents">替换内容</param>
        /// <returns></returns>
        public static  string ReplaceContent( string beginTag, string endTag, string contents, string newContents )
        {
            contents = Regex.Replace(contents, string.Format("{0}((.|\n)*?){1}", beginTag, endTag), String.Format("{0}\r\n{1}\r\n{2}", beginTag, newContents, endTag), RegexOptions.IgnoreCase);
            return contents;
        }

        /// <summary>
        /// 获得标记内的内容
        /// </summary>
        /// <param name="beginTag">开始标记</param>
        /// <param name="endTag">结束标记</param>
        /// <param name="contents">查找内容</param>
        /// <returns></returns>
        public static string GetContent(string beginTag, string endTag, string contents)
        {
            return Regex.Match(contents, string.Format("{0}((.|\n)*?){1}", beginTag, endTag)).Value;
        }
        #endregion

        #region 清除脚本等内容
        /// <summary>
        /// 清除所有HTML标记
        /// </summary>
        /// <param name="contents"></param>
        /// <returns></returns>
        public static string ClearHtml( string contents )
        {
            contents = Regex.Replace(contents, "<(object|script)(.*?)>((.|\n)*?)</(object|script|)>", " ", RegexOptions.IgnoreCase);
            contents = Regex.Replace(contents, "<!--#(.*?)((.|\n)*?)-->", " ", RegexOptions.IgnoreCase);
            contents = Regex.Replace(contents, "<%(.*?)((.|\n)*?)%>", " ", RegexOptions.IgnoreCase);
            //					Contents = regexp.Replace(Contents, "&(nbsp|quot|copy);", "");
            //					Contents = regexp.Replace(Contents, "<([\s\S])+?>", " ", RegexOptions.IgnoreCase);
            //					Contents = regexp.Replace(Contents, "\W", " ");
            return contents;
        }

        /// <summary>
        /// 清除所有HTML标记
        /// </summary>
        /// <param name="contents"></param>
        /// <returns></returns>
        public static string ClearAllHtml( string contents )
        {
            contents = Regex.Replace(contents, @"<([\s\S])+?>", "", RegexOptions.IgnoreCase);
            contents = Regex.Replace(contents, "&(nbsp|quot|copy);", "", RegexOptions.IgnoreCase);
            contents = Regex.Replace(contents, " ", "", RegexOptions.IgnoreCase);
            return contents;
        }
        #endregion

        #region 代码过滤
        /// <summary>
        /// 代码解释功能，目的是为了防止一些人恶意的提交一些代码，影响系统的安全使用，通过字符转换的方法，防止这种现象的发生
        /// </summary>
        /// <param name="html">要转换的数据字符串</param>
        /// <param name="filter">要过滤掉的单个格式</param>
        /// <returns>替换后的字符</returns>
        /// <remarks>
        /// DecodeFilter 方法是为了防止提交恶意代码而使用的，可以过滤 Script,Table,Class,Style,XML,NAMESPACE,MARQUEE,FONT,Object等标签的内容
        /// </remarks>
        /// <example>
        /// 以下示例演示了如何使用 DecodeFilter 过滤包含Script脚本的内容：<br />
        /// <code>		///		
        ///		str = DecodeFilter(str,"SCRIPT");
        /// </code>
        /// </example>
        public static string DecodeFilter( string html, string filter )
        {
            string str = html;
            Regex r;
            Match m;
            switch ( filter.ToUpper() )
            {
                case "SCRIPT":
                    //不允许使用javascript,vbscript等，事件onclick,ondlbclick等
                    str = Regex.Replace(str, "</?script[^>]*>", "");
                    r = new Regex(@"</?script[^>]*>", RegexOptions.IgnoreCase);
                    for ( m = r.Match(str);m.Success;m = m.NextMatch() )
                    {
                        str = str.Replace(m.Groups[0].ToString(), "");
                    }
                    r = new Regex(@"(javascript|jscript|vbscript|vbs):", RegexOptions.IgnoreCase);
                    for ( m = r.Match(str);m.Success;m = m.NextMatch() )
                    {
                        str = str.Replace(m.Groups[0].ToString(), String.Format("{0}：", m.Groups[1]));
                    }
                    r = new Regex(@"on(mouse|exit|error|click|key)", RegexOptions.IgnoreCase);
                    for ( m = r.Match(str);m.Success;m = m.NextMatch() )
                    {
                        str = str.Replace(m.Groups[0].ToString(), "");
                    }
                    r = new Regex(@"&#", RegexOptions.IgnoreCase);
                    for ( m = r.Match(str);m.Success;m = m.NextMatch() )
                    {
                        str = str.Replace(m.Groups[0].ToString(), "");
                    }
                    break;
                case "TABLE":
                    //不允许使用table,th,td,tr标签
                    str = Regex.Replace(str, "</?table[^>]*>", "");
                    str = Regex.Replace(str, "</?tr[^>]*>", "");
                    str = Regex.Replace(str, "</?th[^>]*>", "");
                    str = Regex.Replace(str, "</?td[^>]*>", "");
                    str = Regex.Replace(str, "</?tbody[^>]*>", "");
                    break;
                case "CLASS":
                    //不允许使用 class= 这样的标签
                    r = new Regex(@"(<[^>]+) class=[^ |^>]*([^>]*>)", RegexOptions.IgnoreCase);
                    for ( m = r.Match(str);m.Success;m = m.NextMatch() )
                    {
                        str = str.Replace(m.Groups[0].ToString(), String.Format("{0} {1}", m.Groups[0], m.Groups[1]));
                    }
                    break;
                case "STYLE":
                    //不允许使用 style= 这样的标签
                    r = new Regex("(<[^>]+) style=\"[^\"]*\"([^>]*>)", RegexOptions.IgnoreCase);
                    for ( m = r.Match(str);m.Success;m = m.NextMatch() )
                    {
                        str = str.Replace(m.Groups[0].ToString(), String.Format("{0} {1}", m.Groups[0], m.Groups[1]));
                    }
                    break;
                case "XML":
                    //不允许使用 xml 标签
                    str = Regex.Replace(str, "<\\?xml[^>]*>", "");
                    break;
                case "NAMESPACE":
                    //不允许使用 <o:p></o:p> 这种格式
                    str = Regex.Replace(str, @"<\/?[a-z]+:[^>]*>", "");
                    break;
                case "FONT":
                    //不允许使用 font 标签，不建议使用
                    str = Regex.Replace(str, "</?font[^>]*>", "");
                    break;
                case "MARQUEE":
                    //不允许使用 marquee 标签，也就没有移动滚动的特殊
                    str = Regex.Replace(str, "</?marquee[^>]*>", "");
                    break;
                case "OBJECT":
                    //不允许 object, param, embed 标签，不能嵌入对象
                    str = Regex.Replace(str, "</?object[^>]*>", "");
                    str = Regex.Replace(str, "</?param[^>]*>", "");
                    str = Regex.Replace(str, "</?embed[^>]*>", "");
                    break;
            }
            return str;
        }
        #endregion

        #region 字符加密
        /// <summary>
        /// SHA1
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static string Entrypt( string str )
        {
            return System.Web.Security.FormsAuthentication.HashPasswordForStoringInConfigFile(str, "sha1");

        }
        /// <summary>
        /// MD5
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static string EntryptMD5( string str )
        {
            return System.Web.Security.FormsAuthentication.HashPasswordForStoringInConfigFile(str, "md5");
        }

        /// <summary>
        /// Base64编码
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static string GetBase64Encode(string str)
        {
            return Convert.ToBase64String(System.Text.Encoding.Default.GetBytes(str));
        }

        /// <summary>
        /// Base64解码
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static string GetBase64Decode(string str)
        {
            return Encoding.Default.GetString(Convert.FromBase64String(str));
        }
        #endregion        
        
        #region 截取字符
        /// <summary>
        ///  截取字符
        /// </summary>
        /// <param name="content">需要截取的字符</param>
        /// <param name="length">截取长度</param>
        /// <returns></returns>
        public static string TopString( string content, int length )
        {
            string result = string.Empty;           
            if (content.Length > length)            
            {
                int len = content.Length;
                int n = 0;
                for (int i = 0; i <= len - 1; i++)
                {
                    if (i > len) break;
                    char c = Convert.ToChar(content.Substring(i, 1));
                    if (((int)c > 255) || ((int)c < 0))
                       n = n + 2;
                    else
                        n = n + 1;

                    if (n >= length)
                    {
                        result = content.Substring(0, i + 1) + "…";
                        break;
                    }
                    else
                    {
                        result = content;
                    }

                }

            }
            else result = content;

            return result;
        }
        #endregion

        #region 生成一个随机不重复的字符串
        /// <summary>
        /// 生成一个随机不重复的字符串，用于文件命名
        /// </summary>
        /// <returns>返回</returns>
        public static string RadomFileName()
        {
            return Entrypt(DateTime.Now.ToUniversalTime().ToString().Replace("-", "").Replace(":", "").Replace(" ", "") + GetRandomNext(5).ToString());
        }
        #endregion

        #region 随机数
        /// <summary>
        /// 生成小于10位长度的随机数
        /// </summary>
        /// <param name="length"></param>
        /// <returns></returns>
        public static int GetRandomNext( int length )
        {
            if ( length > 9 )
                throw new System.IndexOutOfRangeException("Length的长度不能大于10");
            Guid gu = Guid.NewGuid();
            string str = "";
            for ( int i = 0;i < gu.ToString().Length;i++ )
            {
                if (Validator.IsNumeric(gu.ToString()[i].ToString()) )
                {
                    str += ( ( gu.ToString()[i] ) );
                }
            }
            int guid = int.Parse(str.Replace("-", "").Substring(0, length));
            if ( !guid.ToString().Length.Equals(length) )
                guid = GetRandomNext(length);
            return guid;
        }
        #endregion

        #region 字符URL编码
        public static string UrlEnCode(string str)
        {
            return HttpUtility.UrlEncode(str);
        }
        #endregion

        #region "隐藏IP地址最后一位用*号代替"
        /// <summary>
        /// 隐藏IP地址最后一位用*号代替
        /// </summary>
        /// <param name="Ipaddress">IP地址:192.168.34.23</param>
        /// <returns></returns>
        public static string HidenLastIP(string ip)
        {
            if (ip.Trim() != string.Empty)
            {
                return ip.Substring(0, ip.LastIndexOf(".")) + ".*";
            }
            else return string.Empty;
        }
        #endregion
        
        #region "按字符串位数补0"
        /// <summary>
        /// 按字符串位数补0
        /// </summary>
        /// <param name="CharTxt">字符串</param>
        /// <param name="CharLen">字符长度</param>
        /// <returns></returns>
        public static string FillZero(string CharTxt, int CharLen)
        {
            if (CharTxt.Length < CharLen)
            {
                StringBuilder sb = new StringBuilder();
                for (int i = 0; i < CharLen - CharTxt.Length; i++)
                {
                    sb.Append("0");
                }
                sb.Append(CharTxt);
                return sb.ToString();
            }
            else
            {
                return CharTxt;
            }
        }

        #endregion

        #region "正式表达式验证"
        /// <summary>
        /// 正式表达式验证
        /// </summary>
        /// <param name="C_Value">验证字符</param>
        /// <param name="C_Str">正式表达式</param>
        /// <returns>符合true不符合false</returns>
        public static bool CheckRegex(string content, string regex)
        {
            Regex match = new Regex(regex, RegexOptions.Compiled);
            return match.Match(content).Success;
        }
        #endregion
        

       /// <summary>
        /// 从字符串中的尾部删除指定的字符串
       /// </summary>
       /// <param name="sourceString">源内容</param>
       /// <param name="removedString">要移除的字符</param>
       /// <returns></returns>
        public static string Remove(string sourceString, string removedString)
        {
            try
            {
                if (sourceString.IndexOf(removedString) < 0)
                    return sourceString;

                string result = sourceString;
                int lengthOfSourceString = sourceString.Length;
                int lengthOfRemovedString = removedString.Length;
                int startIndex = lengthOfSourceString - lengthOfRemovedString;
                string tempSubString = sourceString.Substring(startIndex);
                if (tempSubString.ToUpper() == removedString.ToUpper())
                {
                    result = sourceString.Remove(startIndex, lengthOfRemovedString);
                }
                return result;
            }
            catch
            {
                return sourceString;
            }
        }

        /// <summary>
        /// 获取拆分符右边的字符串
        /// </summary>
        /// <param name="sourceString"></param>
        /// <param name="splitChar"></param>
        /// <returns></returns>
        public static string RightSplit(string sourceString, char splitChar)
        {
            string result = null;
            string[] tempString = sourceString.Split(splitChar);
            if (tempString.Length > 0)
            {
                result = tempString[tempString.Length - 1].ToString();
            }
            return result;
        }

        /// <summary>
        /// 获取拆分符左边的字符串
        /// </summary>
        /// <param name="sourceString"></param>
        /// <param name="splitChar"></param>
        /// <returns></returns>
        public static string LeftSplit(string sourceString, char splitChar)
        {
            string result = null;
            string[] tempString = sourceString.Split(splitChar);
            if (tempString.Length > 0)
            {
                result = tempString[0].ToString();
            }
            return result;
        }

        /// <summary>
        /// 删除不可见字符
        /// </summary>
        /// <param name="sourceString"></param>
        /// <returns></returns>
        public static string DeleteUnVisibleChar(string sourceString)
        {
            System.Text.StringBuilder sBuilder = new System.Text.StringBuilder(131);
            for (int i = 0; i < sourceString.Length; i++)
            {
                int Unicode = sourceString[i];
                if (Unicode >= 16)
                {
                    sBuilder.Append(sourceString[i].ToString());
                }
            }
            return sBuilder.ToString();
        }

        /// <summary>
        /// 获取数组元素的合并字符串
        /// </summary>
        /// <param name="stringArray"></param>
        /// <returns></returns>
        public static string GetArrayString(string[] stringArray)
        {
            string totalString = null;
            for (int i = 0; i < stringArray.Length; i++)
            {
                totalString = totalString + stringArray[i];
            }
            return totalString;
        }

        /// <summary>
        /// 获取某一字符串在字符串数组中出现的次数
        /// </summary>
        /// <param name="stringArray"></param>
        /// <param name="findString"></param>
        /// <returns></returns>
        public static int GetStringCount(string[] stringArray, string findString)
        {
            int count = -1;
            string totalString = GetArrayString(stringArray);
            string subString = totalString;

            while (subString.IndexOf(findString) >= 0)
            {
                subString = totalString.Substring(subString.IndexOf(findString));
                count += 1;
            }
            return count;
        }

        /// <summary>
        /// 获取某一字符串在字符串中出现的次数
        /// </summary>
        /// <param name="stringArray">原字符串</param>
        /// <param name="findString">匹配字符串</param>
        /// <returns>
        ///     匹配字符串数量
        /// </returns>
        public static int GetStringCount(string sourceString, string findString)
        {
            int count = 0;
            int findStringLength = findString.Length;
            string subString = sourceString;

            while (subString.IndexOf(findString) >= 0)
            {
                subString = subString.Substring(subString.IndexOf(findString) + findStringLength);
                count += 1;
            }
            return count;
        }

       /// <summary>
        ///  截取从startString开始到原字符串结尾的所有字符   
       /// </summary>
       /// <param name="sourceString"></param>
       /// <param name="startString"></param>
       /// <returns></returns>
        public static string GetSubString(string sourceString, string startString)
        {
            try
            {
                int index = sourceString.ToUpper().IndexOf(startString);
                if (index > 0)
                {
                    return sourceString.Substring(index);
                }
                return sourceString;
            }
            catch
            {
                return "";
            }
        }

        /// <summary>
        /// 截取字符串里面的字母
        /// </summary>
        /// <param name="sourceString"></param>
        /// <returns></returns>
        public static string GetLetter(string sourceString)
        {
            Regex regex = new Regex("^[A-Za-z]+$", RegexOptions.Compiled);
            char[] stringChar = sourceString.ToCharArray();
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < stringChar.Length; i++)
            {
                if (regex.IsMatch((stringChar[i]).ToString()))
                {
                    sb.Append(stringChar[i]);
                }
            }
            return sb.ToString();
        }

 
        /// <summary>
        /// 截取字符串里的数字
        /// </summary>
        /// <param name="sourceString"></param>
        /// <returns></returns>
        public static string GetNumString(string sourceString)
        {
            Regex regex = new Regex("^-?\\d+$", RegexOptions.Compiled);
            char[] stringChar = sourceString.ToCharArray();
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < stringChar.Length; i++)
            {
                if (regex.IsMatch((stringChar[i]).ToString()))
                {
                    sb.Append(stringChar[i]);
                }
            }
            return sb.ToString();
        }

        /// <summary>
        /// 截取字符
        /// </summary>
        /// <param name="sourceString">源字符</param>
        /// <param name="beginRemovedString"></param>
        /// <param name="endRemovedString"></param>
        /// <returns></returns>
        public static string GetSubString(string sourceString, string beginRemovedString, string endRemovedString)
        {
            try
            {
                if (sourceString.IndexOf(beginRemovedString) != 0)
                    beginRemovedString = "";

                if (sourceString.LastIndexOf(endRemovedString, sourceString.Length - endRemovedString.Length) < 0)
                    endRemovedString = "";

                int startIndex = beginRemovedString.Length;
                int length = sourceString.Length - beginRemovedString.Length - endRemovedString.Length;
                if (length > 0)
                {
                    return sourceString.Substring(startIndex, length);
                }
                return sourceString;
            }
            catch
            {
                return sourceString; ;
            }
        }

        /// <summary>
        /// 按字节数取出字符串的长度
        /// </summary>
        /// <param name="str">要计算的字符串</param>
        /// <returns>字符串的字节数</returns>
        public static int GetByteCount(string str)
        {
            int intCharCount = 0;
            for (int i = 0; i < str.Length; i++)
            {
                if (System.Text.UTF8Encoding.UTF8.GetByteCount(str.Substring(i, 1)) == 3)
                {
                    intCharCount = intCharCount + 2;
                }
                else
                {
                    intCharCount = intCharCount + 1;
                }
            }
            return intCharCount;
        }

        /// <summary>
        /// 按字节数要在字符串的位置
        /// </summary>
        /// <param name="intIns">字符串的位置</param>
        /// <param name="str">要计算的字符串</param>
        /// <returns>字节的位置</returns>
        public static int GetByteIndex(int intIns, string str)
        {
            int intReIns = 0;
            if (str.Trim() == "")
            {
                return intIns;
            }
            for (int i = 0; i < str.Length; i++)
            {
                if (System.Text.UTF8Encoding.UTF8.GetByteCount(str.Substring(i, 1)) == 3)
                {
                    intReIns = intReIns + 2;
                }
                else
                {
                    intReIns = intReIns + 1;
                }
                if (intReIns >= intIns)
                {
                    intReIns = i + 1;
                    break;
                }
            }
            return intReIns;
        }

        /// <summary>
        /// 截取指定长度的字符串(包括双字节字符)
        /// </summary>
        /// <param name="str"></param>
        /// <param name="length"></param>
        /// <returns></returns>
        public static string GetSubString(string str, int length)
        {
            Regex regex = new Regex("[^\x00-\xff]", RegexOptions.Compiled);
            char[] stringChar = str.ToCharArray();
            StringBuilder sb = new StringBuilder();
            int nLength = 0;
            for (int i = 0; i < stringChar.Length; i++)
            {
                if (regex.IsMatch((stringChar[i]).ToString()))
                {
                    nLength += 2;
                }
                else
                {
                    nLength = nLength + 1;
                }

                if (nLength <= length)
                {
                    sb.Append(stringChar[i]);
                }
                else
                {
                    break;
                }
            }
            return sb.ToString();
        }
 
    }