字符串的处理函数集

   下面的字符串的处理函数集来自Seaskyer

#region "字符串的处理函数集"
        
        /// <summary>
        /// 字符串的处理函数集
        /// </summary>
        public class Str
        {
            /// <summary>
            /// 将 Stream 转化成 string
            /// </summary>
            /// <param name="s">Stream流</param>
            /// <returns>string</returns>
            public static string ConvertStreamToString(Stream s)
            {
                string strResult    = "";
                StreamReader sr        = new StreamReader( s, Encoding.UTF8 );

                Char[] read = new Char[256];

                // Read 256 charcters at a time.    
                int count = sr.Read( read, 0, 256 );

                while (count > 0) 
                {
                    // Dump the 256 characters on a string and display the string onto the console.
                    string str = new String(read, 0, count);
                    strResult += str;
                    count = sr.Read(read, 0, 256);
                }


                // 释放资源
                sr.Close();

                return strResult;
            }

            /// <summary>
            /// 对传递的参数字符串进行处理，防止注入式攻击
            /// </summary>
            /// <param name="str">传递的参数字符串</param>
            /// <returns>String</returns>
            public static string ConvertSql(string str)
            {
                str = str.Trim();
                str = str.Replace("'", "''");
                str = str.Replace(";--", "");
                str = str.Replace("=", "");
                str = str.Replace(" or ", "");
                str = str.Replace(" and ", "");

                return str;
            }


            /// <summary>
            /// 格式化占用空间大小的输出
            /// </summary>
            /// <param name="size">大小</param>
            /// <returns>返回 String</returns>
            public static string FormatNUM(long size)
            {
                decimal NUM;
                string strResult;

                if( size > 1073741824 )
                {
                    NUM = (Convert.ToDecimal(size)/Convert.ToDecimal(1073741824));
                    strResult = NUM.ToString("N") + " M";
                }
                else if( size > 1048576 )
                {
                    NUM = (Convert.ToDecimal(size)/Convert.ToDecimal(1048576));
                    strResult = NUM.ToString("N") + " M";
                }
                else if( size > 1024 )
                {
                    NUM = (Convert.ToDecimal(size)/Convert.ToDecimal(1024));
                    strResult = NUM.ToString("N") + " KB";
                }
                else
                {
                    strResult = size + " 字节";
                }

                return strResult;
            }

            /// <summary>
            /// 判断字符串是否为有效的邮件地址
            /// </summary>
            /// <param name="email"></param>
            /// <returns></returns>
            public static bool IsValidEmail(string email)
            {
                return Regex.IsMatch(email,@"^.+@([?)[a-zA-Z0-9-.]+.([a-zA-Z]{2,3}|[0-9]{1,3})(]?)$");
            }

            /// <summary>
            /// 判断字符串是否为有效的URL地址
            /// </summary>
            /// <param name="url"></param>
            /// <returns></returns>
            public static bool IsValidURL(string url)
            {
                return Regex.IsMatch(url,@"^(http|https|ftp)://[a-zA-Z0-9-.]+.[a-zA-Z]{2,3}(:[a-zA-Z0-9]*)?/?([a-zA-Z0-9-._?,'//+&%$#=~])*[^.,)(s]$");
            }

            /// <summary>
            /// 判断字符串是否为Int类型的
            /// </summary>
            /// <param name="val"></param>
            /// <returns></returns>
            public static bool IsValidInt(string val)
            {
                return Regex.IsMatch(val,@"^[1-9]d*.?[0]*$");
            }

            /// <summary>
            /// 检测字符串是否全为正整数
            /// </summary>
            /// <param name="str"></param>
            /// <returns></returns>
            public static bool IsNum(string str)
            {
                bool blResult = true;//默认状态下是数字

                if(str == "")
                    blResult = false;
                else
                {
                    foreach(char Char in str)
                    {
                        if(!char.IsNumber(Char))
                        {
                            blResult = false;
                            break;
                        }
                    }
                    if(blResult)
                    {
                        if(int.Parse(str) == 0)
                            blResult = false;
                    }
                }
                return blResult;
            }

            /// <summary>
            /// 检测字符串是否全为数字型
            /// </summary>
            /// <param name="str"></param>
            /// <returns></returns>
            public static bool IsDouble(string str)
            {
                bool blResult = true;//默认状态下是数字

                if(str == "")
                    blResult = false;
                else
                {
                    foreach(char Char in str)
                    {
                        if(!char.IsNumber(Char) && Char.ToString() != "-")
                        {
                            blResult = false;
                            break;
                        }
                    }
                }
                return blResult;
            }

            /// <summary>
            /// 输出由同一字符组成的指定长度的字符串
            /// </summary>
            /// <param name="Char">输出字符，如：A</param>
            /// <param name="i">指定长度</param>
            /// <returns></returns>
            public static string Strings(char Char, int i)
            {
                string strResult = null;

                for(int j = 0; j < i; j++)
                {
                    strResult += Char;
                }
                return strResult;
            }


            /// <summary>
            /// 返回字符串的真实长度，一个汉字字符相当于两个单位长度
            /// </summary>
            /// <param name="str">指定字符串</param>
            /// <returns></returns>
            public static int Len(string str)
            {
                int intResult = 0;

                foreach(char Char in str)
                {
                    if((int)Char > 127)
                        intResult += 2;
                    else
                        intResult ++;
                }
                return intResult;
            }


            /// <summary>
            /// 以日期为标准获得一个绝对的名称
            /// </summary>
            /// <returns>返回 String</returns>
            public static string MakeName()
            {
                /*
                string y = DateTime.Now.Year.ToString();
                string m = DateTime.Now.Month.ToString();
                string d = DateTime.Now.Day.ToString();
                string h = DateTime.Now.Hour.ToString();
                string n = DateTime.Now.Minute.ToString();
                string s = DateTime.Now.Second.ToString();
                return y + m + d + h + n + s;
                */

                return DateTime.Now.ToString("yyMMddHHmmss");
            }


            /// <summary>
            /// 返回字符串的真实长度，一个汉字字符相当于两个单位长度(使用Encoding类)
            /// </summary>
            /// <param name="str">指定字符串</param>
            /// <returns></returns>
            public static int getLen(string str)
            {
                int intResult = 0;
                Encoding gb2312 = Encoding.GetEncoding("gb2312"); 
                byte[] bytes = gb2312.GetBytes(str);
                intResult = bytes.Length;
                return intResult;
            }


            /// <summary>
            /// 按照字符串的实际长度截取指定长度的字符串
            /// </summary>
            /// <param name="str">字符串</param>
            /// <param name="Length">指定长度</param>
            /// <returns></returns>
            public static string CutLen(string str, int Length)
            {
                int i = 0, j = 0;

                foreach(char Char in str)
                {
                    if((int)Char > 127)
                        i += 2;
                    else
                        i ++;

                    if(i > Length)
                    {
                        str = str.Substring(0, j - 2) + "...";
                        break;
                    }
                    j ++;
                }
                return str;
            }


            /// <summary>
            /// 获取指定长度的纯数字随机数字串
            /// </summary>
            /// <param name="intLong">数字串长度</param>
            /// <returns>字符串</returns>
            public static string RandomNUM(int intLong)
            {
                string strResult = "";

                Random r = new Random();
                for(int i = 0; i < intLong; i ++)
                {
                    strResult = strResult + r.Next(10);
                }

                return strResult;
            }

            /// <summary>
            /// 获取一个由26个小写字母组成的指定长度的随即字符串
            /// </summary>
            /// <param name="intLong">指定长度</param>
            /// <returns></returns>
            public static string RandomSTR(int intLong)
            {
                string strResult = "";
                string[] array = {"a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"};

                Random r = new Random();

                for(int i = 0; i < intLong; i++)
                {
                    strResult += array[r.Next(26)];
                }

                return strResult;
            }

            /// <summary>
            /// 获取一个由数字和26个小写字母组成的指定长度的随即字符串
            /// </summary>
            /// <param name="intLong">指定长度</param>
            /// <returns></returns>
            public static string RandomNUMSTR(int intLong)
            {
                string strResult = "";
                string[] array = {"0","1","2","3","4","5","6","7","8","9","a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"};

                Random r = new Random();

                for(int i = 0; i < intLong; i++)
                {
                    strResult += array[r.Next(36)];
                }

                return strResult;
            }

            /// <summary>
            /// 将简体中文转化成繁体中文
            /// </summary>
            /// <param name="str">简体中文字符串</param>
            /// <returns>string</returns>
            public static string ConvertToTraditionalChinese(string str)
            {
                return Microsoft.VisualBasic.Strings.StrConv(str, VbStrConv.TraditionalChinese, System.Globalization.CultureInfo.CurrentUICulture.LCID);
            }

            /// <summary>
            /// 将繁体中文转化成简体中文
            /// </summary>
            /// <param name="str">繁体中文字符串</param>
            /// <returns>string</returns>
            public static string ConvertToSimplifiedChinese(string str)
            {
                return Microsoft.VisualBasic.Strings.StrConv(str, VbStrConv.SimplifiedChinese, System.Globalization.CultureInfo.CurrentUICulture.LCID);
            }


            /// <summary>
            /// 将指定字符串中的汉字转换为拼音首字母的缩写，其中非汉字保留为原字符
            /// </summary>
            /// <param name="text"></param>
            /// <returns></returns>
             public static string ConvertSpellFirst(string text)
            {
                char pinyin;
                byte[] array;
                StringBuilder sb = new StringBuilder(text.Length); 
                foreach(char c in text)
                {
                    pinyin = c;
                    array = Encoding.Default.GetBytes(new char[]{c});

                    if(array.Length == 2)
                    {
                        int i = array[0] * 0x100 + array[1];

                        if(i < 0xB0A1) pinyin = c; else
                            if(i < 0xB0C5) pinyin = 'a'; else
                            if(i < 0xB2C1) pinyin = 'b'; else
                            if(i < 0xB4EE) pinyin = 'c'; else
                            if(i < 0xB6EA) pinyin = 'd'; else
                            if(i < 0xB7A2) pinyin = 'e'; else
                            if(i < 0xB8C1) pinyin = 'f'; else
                            if(i < 0xB9FE) pinyin = 'g'; else
                            if(i < 0xBBF7) pinyin = 'h'; else
                            if(i < 0xBFA6) pinyin = 'g'; else
                            if(i < 0xC0AC) pinyin = 'k'; else
                            if(i < 0xC2E8) pinyin = 'l'; else
                            if(i < 0xC4C3) pinyin = 'm'; else
                            if(i < 0xC5B6) pinyin = 'n'; else
                            if(i < 0xC5BE) pinyin = 'o'; else
                            if(i < 0xC6DA) pinyin = 'p'; else
                            if(i < 0xC8BB) pinyin = 'q'; else
                            if(i < 0xC8F6) pinyin = 'r'; else
                            if(i < 0xCBFA) pinyin = 's'; else
                            if(i < 0xCDDA) pinyin = 't'; else
                            if(i < 0xCEF4) pinyin = 'w'; else
                            if(i < 0xD1B9) pinyin = 'x'; else
                            if(i < 0xD4D1) pinyin = 'y'; else
                            if(i < 0xD7FA) pinyin = 'z';
                    }

                    sb.Append(pinyin);
                }

                return sb.ToString();
            }
                      #endregion