字符操作通用类

#region 字符操作通用类

        /// <summary>
        /// 有关对字符操作公用组件
        /// </summary>

        public class StringOption
        {

            private const string Str1 = "&@%FwG122*";
            private const string Str2 = "%@&122*FwG";
            /// <summary>
            /// 参数替换函数
            /// </summary>
            /// <param name="SourceString"></param>
            /// <returns></returns>
            public static string EnReplaceString(string SourceString)
            {
                return SourceString.Replace(",", Str1).Replace("|", Str2);
            }
            /// <summary>
            /// 参数反替换函数
            /// </summary>
            /// <param name="SourceString"></param>
            /// <returns></returns>
            public static string DesReplaceString(string SourceString)
            {
                return SourceString.Replace(Str1, ",").Replace(Str2, "|");
            }
            /// <summary>
            /// 字符串加密组件
            /// </summary>
            public class Encrypt
            {

                #region "变量定义"
                private SymmetricAlgorithm mCSP;
                private const string CIV = "kXwL7X2+fgM=";//密钥
                private const string CKEY = "FwGQWRRgKCI=";//初始化向量
                #endregion

                #region "实例化"
                /// <summary>
                /// 实例化
                /// </summary>
                public Encrypt()
                {
                    mCSP = new DESCryptoServiceProvider();
                }
                #endregion

                /// <summary>
                ///加密字符串
                /// </summary>
                /// <param name="Value">要加密的字符</param>
                /// <returns>加密了的字符串</returns>
                public string EncryptString(string Value)
                {
                    ICryptoTransform ct;//定义基本的加密运算符
                    MemoryStream ms;
                    CryptoStream cs;//定义将数据流转链接到加密转换的流
                    byte[] byt;
                    //CreateEncryptor创建加密对象
                    ct = mCSP.CreateEncryptor(Convert.FromBase64String(CKEY), Convert.FromBase64String(CIV));

                    byt = Encoding.UTF8.GetBytes(Value);

                    ms = new MemoryStream();
                    cs = new CryptoStream(ms, ct, CryptoStreamMode.Write);
                    cs.Write(byt, 0, byt.Length);
                    cs.FlushFinalBlock();

                    cs.Close();

                    return Convert.ToBase64String(ms.ToArray());
                }

                /// <summary>
                /// 解密字符串
                /// </summary>
                /// <param name="Value">要解密字符串</param>
                /// <returns>解密了的字符串</returns>
                public string DecryptString(string Value)
                {
                    ICryptoTransform ct;
                    MemoryStream ms;
                    CryptoStream cs;
                    byte[] byt;

                    ct = mCSP.CreateDecryptor(Convert.FromBase64String(CKEY), Convert.FromBase64String(CIV));

                    byt = Convert.FromBase64String(Value);

                    ms = new MemoryStream();
                    cs = new CryptoStream(ms, ct, CryptoStreamMode.Write);
                    cs.Write(byt, 0, byt.Length);
                    cs.FlushFinalBlock();

                    cs.Close();

                    return Encoding.UTF8.GetString(ms.ToArray());
                }

            }

            /// <summary>
            /// 全半角转换组件
            /// </summary>
            public class ConvertDBCAndSBC
            {
                /// <summary>
                /// 转全角的函数
                /// 全角空格为12288，半角空格为32
                /// 其他字符半角(33-126)与全角(65281-65374)的对应关系是：均相差65248
                /// </summary>
                /// <param name="input">任意字符串</param>
                /// <returns>全角字符串</returns>
                public string DBCToSBC(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);

                }

                /// <summary>
                /// 转半角的函数
                /// 全角空格为12288，半角空格为32
                /// 其他字符半角(33-126)与全角(65281-65374)的对应关系是：均相差65248
                /// </summary>
                /// <param name="input">任意字符串</param>
                /// <returns>半角字符串</returns>
                public string SBCToDBC(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);
                }

            }

            /// <summary>
            /// 金额转换成大写
            /// </summary>
            public class MoneyConvertChinese
            {
                /// <summary>
                ///金额转换成大写
                /// </summary>
                /// <param name="LowerMoney">要转换的金额</param>
                /// <returns>大写金额</returns>
                public string MoneyToChinese(string LowerMoney)
                {
                    string functionReturnValue = null;
                    bool IsNegative = false;//是否是负数
                    if (LowerMoney.Trim().Substring(0, 1) == "-")
                    {
                        LowerMoney = LowerMoney.Trim().Remove(0, 1);
                        IsNegative = true;
                    }
                    try
                    {
                        string strLower = null;
                        string strUPart = null;
                        string strUpper = null;
                        int iTemp = 0;
                        LowerMoney = Math.Round(double.Parse(LowerMoney), 2).ToString();
                        //保留到两位小数
                        if (LowerMoney.IndexOf(".") > 0)
                        {
                            if (LowerMoney.IndexOf(".") == LowerMoney.Length - 2)
                            {
                                LowerMoney = LowerMoney + "0";
                            }
                        }
                        else
                        {
                            LowerMoney = LowerMoney + ".00";
                        }
                        strLower = LowerMoney;

                        iTemp = 1;
                        strUpper = "";
                        while (iTemp <= strLower.Length)
                        {
                            switch (strLower.Substring(strLower.Length - iTemp, 1))
                            {
                                case ".":
                                    strUPart = "圆";
                                    break;
                                case "0":
                                    strUPart = "零";
                                    break;
                                case "1":
                                    strUPart = "壹";
                                    break;
                                case "2":
                                    strUPart = "贰";
                                    break;
                                case "3":
                                    strUPart = "叁";
                                    break;
                                case "4":
                                    strUPart = "肆";
                                    break;
                                case "5":
                                    strUPart = "伍";
                                    break;
                                case "6":
                                    strUPart = "陆";
                                    break;
                                case "7":
                                    strUPart = "柒";
                                    break;
                                case "8":
                                    strUPart = "捌";
                                    break;
                                case "9":
                                    strUPart = "玖";
                                    break;
                            }
                            switch (iTemp)
                            {
                                case 1:
                                    strUPart = strUPart + "分";
                                    break;
                                case 2:
                                    strUPart = strUPart + "角";
                                    break;
                                case 3:
                                    strUPart = strUPart + "";
                                    break;
                                case 4:
                                    strUPart = strUPart + "";
                                    break;
                                case 5:
                                    strUPart = strUPart + "拾";
                                    break;
                                case 6:
                                    strUPart = strUPart + "佰";
                                    break;
                                case 7:
                                    strUPart = strUPart + "仟";
                                    break;
                                case 8:
                                    strUPart = strUPart + "万";
                                    break;
                                case 9:
                                    strUPart = strUPart + "拾";
                                    break;
                                case 10:
                                    strUPart = strUPart + "佰";
                                    break;
                                case 11:
                                    strUPart = strUPart + "仟";
                                    break;
                                case 12:
                                    strUPart = strUPart + "亿";
                                    break;
                                case 13:
                                    strUPart = strUPart + "拾";
                                    break;
                                case 14:
                                    strUPart = strUPart + "佰";
                                    break;
                                case 15:
                                    strUPart = strUPart + "仟";
                                    break;
                                case 16:
                                    strUPart = strUPart + "万";
                                    break;
                                default:
                                    strUPart = strUPart + "";
                                    break;
                            }
                            strUpper = strUPart + strUpper;
                            iTemp = iTemp + 1;
                        }

                        strUpper = strUpper.Replace("零拾", "零");
                        strUpper = strUpper.Replace("零佰", "零");
                        strUpper = strUpper.Replace("零仟", "零");
                        strUpper = strUpper.Replace("零零零", "零");
                        strUpper = strUpper.Replace("零零", "零");
                        strUpper = strUpper.Replace("零角零分", "整");
                        strUpper = strUpper.Replace("零分", "整");
                        strUpper = strUpper.Replace("零角", "零");
                        strUpper = strUpper.Replace("零亿零万零圆", "亿圆");
                        strUpper = strUpper.Replace("亿零万零圆", "亿圆");
                        strUpper = strUpper.Replace("零亿零万", "亿");
                        strUpper = strUpper.Replace("零万零圆", "万圆");
                        strUpper = strUpper.Replace("万零圆", "万圆");
                        strUpper = strUpper.Replace("零亿", "亿");
                        strUpper = strUpper.Replace("零万", "万");
                        strUpper = strUpper.Replace("零圆", "圆");
                        strUpper = strUpper.Replace("零零", "零");
                        //对壹圆以下的金额的处理
                        if (strUpper.Substring(0, 1) == "圆")
                        {
                            strUpper = strUpper.Substring(1, strUpper.Length - 1);
                        }

                        if (strUpper.Substring(0, 1) == "零")
                        {
                            strUpper = strUpper.Substring(1, strUpper.Length - 1);
                        }

                        if (strUpper.Substring(0, 1) == "角")
                        {
                            strUpper = strUpper.Substring(1, strUpper.Length - 1);
                        }

                        if (strUpper.Substring(0, 1) == "分")
                        {
                            strUpper = strUpper.Substring(1, strUpper.Length - 1);
                        }

                        if (strUpper.Substring(0, 1) == "整")
                        {
                            strUpper = "零圆整";
                        }
                        functionReturnValue = strUpper;
                    }
                    catch
                    {
                        functionReturnValue = "零圆整";
                    }
                    if (IsNegative == true)
                    {
                        return "负" + functionReturnValue;
                    }
                    else
                    {
                        return functionReturnValue;
                    }
                }
            }

        }

        /// <summary>
        /// 常用正则表达式类
        /// </summary>
        /// <summary>
        /// 对用户字符检测防止非法字符
        /// </summary>
        public class RegularString
        {
            //email地址
            /// <summary>
            /// email地址,是则返回True
            /// </summary>
            /// <param name="email"></param>
            /// <returns></returns>
            public bool IsEmail(string email)
            {
                string reg=@"^\w+((-\w+)|(\.\w+))*\@[A-Za-z0-9]+((\.|-)[A-Za-z0-9]+)*\.[A-Za-z0-9]+$";
                return Regex.IsMatch(email, reg);
            }

            //数字和字母
            /// <summary>
            /// 数字和字母,是则返回True
            /// </summary>
            /// <param name="email"></param>
            /// <returns></returns>
            public bool IsFigureLetter(string email)
            {
                string reg = @"^[A-Za-z0-9]+$";
                return Regex.IsMatch(email, reg);
            }

            //数字
            /// <summary>
            /// 数字,是则返回True
            /// </summary>
            /// <param name="email"></param>
            /// <returns></returns>
            public bool IsFigure(string email)
            {
                string reg = @"^[0-9]+$";
                return Regex.IsMatch(email, reg);
            }

            //浮点数
            /// <summary>
            /// 浮点数,是则返回True
            /// </summary>
            /// <param name="email"></param>
            /// <returns></returns>
            public bool IsFloat(string email)
            {
                string reg = @"^(-?\\d+)(\\.\\d+)?$";
                return Regex.IsMatch(email, reg);
            }

            //字母
            /// <summary>
            /// 字母,是则返回True
            /// </summary>
            /// <param name="email"></param>
            /// <returns></returns>
            public bool IsLetter(string email)
            {
                string reg = @"^[A-Za-z]+$";
                return Regex.IsMatch(email, reg);
            }

            //日期
            /// <summary>
            /// 日期,是则返回True
            /// </summary>
            /// <param name="email"></param>
            /// <returns></returns>
            public bool IsDate(string email)
            {
                string reg = @"\d{4}[年|\-|\.]\d{\1-\12}[月|\-|\.]\d{\1-\31}日?";
                return Regex.IsMatch(email, reg);
            }

            //国内电话
            /// <summary>
            /// 国内电话,是则返回True
            /// </summary>
            /// <param name="email"></param>
            /// <returns></returns>
            public bool IsPhone(string email)
            {
                string reg = @"(\d{3}-|\d{4}-)?(\d{8}|\d{7})?";
                return Regex.IsMatch(email, reg);
            }

            //腾讯QQ
            /// <summary>
            /// 腾讯QQ,是则返回True
            /// </summary>
            /// <param name="email"></param>
            /// <returns></returns>
            public bool IsQQ(string email)
            {
                string reg = @"^[1-9]*[1-9][0-9]*$";
                return Regex.IsMatch(email, reg);
            }

            //中国邮政编码
            /// <summary>
            /// 中国邮政编码,是则返回True
            /// </summary>
            /// <param name="email"></param>
            /// <returns></returns>
            public bool IsPostalcode(string email)
            {
                string reg = @"[1-9]\d(?!\d)";
                return Regex.IsMatch(email, reg);
            }

            //身份证为15位或18位
            /// <summary>
            /// 15位或18位身份证,是则返回True
            /// </summary>
            /// <param name="email"></param>
            /// <returns></returns>
            public bool IsIdNumber(string email)
            {
                string reg = @"\d{17}[\d|X]|\d{15}";
                return Regex.IsMatch(email, reg);
            }
        }

        #endregion