金额大小写转换-优快云博客

Code
namespace ZTSM.Interfaces
{
    /// <summary>
    ///金额转换的接口
    /// </summary>
    public interface IAmountConversion
    {
        string WithZero();
        string WithOne();
        string WithTwo();
        string WithThree();
        string WithFour();
        string WithFive();
        string WithSix();
        string WithSeven();
        string WithEight();
        string WithNine();
        string RangeLocation();
        string  Multiplier();
        void Interpret(ZTSM.Entity.Amount amount);

    }
}

Code
namespace ZTSM.Auxiliary
{
    /// <summary>
    ///将阿拉伯数字金额转换为中文大写金额的抽象类
    /// </summary>
    public abstract class CnCapitalAmount :ZTSM.Interfaces.IAmountConversion
    {
      #region IAmountConversion 成员
        /// <summary>
        /// 匹配0
        /// </summary>
        /// <returns>0</returns>
        public  string WithZero()
        {
            return "0";
        }
        /// <summary>
        /// 匹配1
        /// </summary>
        /// <returns>1</returns>
        public  string WithOne()
        {
            return "1";
        }
        /// <summary>
        /// 匹配2
        /// </summary>
        /// <returns>2</returns>
        public  string WithTwo()
        {
            return "2";
        }
        /// <summary>
        /// 匹配3
        /// </summary>
        /// <returns>3</returns>
        public  string WithThree()
        {
            return "3";
        }
        /// <summary>
        /// 匹配4
        /// </summary>
        /// <returns>4</returns>
        public  string WithFour()
        {
            return "4";
        }
        /// <summary>
        /// 匹配5
        /// </summary>
        /// <returns>5</returns>
        public  string WithFive()
        {
            return "5";
        }
        /// <summary>
        /// 匹配6
        /// </summary>
        /// <returns>6</returns>
        public  string WithSix()
        {
            return "6";
        }
        /// <summary>
        /// 匹配7
        /// </summary>
        /// <returns>7</returns>
        public  string WithSeven()
        {
            return "7";
        }
        /// <summary>
        /// 匹配8
        /// </summary>
        /// <returns>8</returns>
        public  string WithEight()
        {
            return "8";
        }
        /// <summary>
        /// 匹配9
        /// </summary>
        /// <returns>9</returns>
        public  string WithNine()
        {
            return "9";
        }
        /// <summary>
        /// 金额字符串的范围位置
        /// </summary>
        /// <returns>范围位置的字符串</returns>
        public  virtual string RangeLocation()
        {
            return null;
        }
        /// <summary>
        /// 金额的单位乘积或者单位名称
        /// </summary>
        /// <returns></returns>
        public  virtual string Multiplier()
        {
            return null;
        }
        /// <summary>
        /// 解释器方法。将小写金额解释为中文大写
        /// </summary>
        /// <param name="amount">金额实体类</param>
        public void Interpret(ZTSM.Entity.Amount amount)
        {
            if (!ZTSM.ZTSMTools.Validations.IsDigital(ZTSM.ZTSMTools.Conversion.RemoveDecimalSymbol(amount.InputAmount)))
            {
                amount.OutputAmount = "无法转换非数字字符串！请输入整数部分在16位以内小写数字";
                return;
            }
            if (double.Parse(amount.InputAmount)> double.Parse(System.Configuration.ConfigurationManager.AppSettings["AmountRange"]))
            {
                amount.OutputAmount = "数字过大，本程序暂时只能转换整数部分在16位以以内的小写数字。";
                return;
            }
            string[] strArray = amount.InputAmount.Split('.');//按小数点分割
            if (strArray.Length < 2)//说明只有整数部分
            {
                if (string.IsNullOrEmpty(amount.IntegerString))//只有保存整数的字符串属性是空的时，才给予赋值
                {
                    amount.IntegerString = Math.Abs(decimal.Parse( strArray[0])).ToString();//进行数学转换是保证剔除前面的零，如000123456
                }
            }
            else//说明小数部分和整数部分都有
            {
                if (string.IsNullOrEmpty(amount.IntegerString))
                {
                    amount.IntegerString =Math.Abs(decimal.Parse( strArray[0])).ToString();//进行数学转换是保证剔除前面的零，如000123456
                }
                if (string.IsNullOrEmpty(amount.DecimalString))//只有保存小数的字符串属性是空的时，才给予赋值
                {
                    if (strArray[1].Length > 2)//如果小数部分超过2位数
                    {
                        string tempStr = strArray[1].Substring(0, 3);//只取3位
                        double db = int.Parse(tempStr) * 0.1;//转换为双精度浮点数，如123转为12.3，但023却会转为2.3
                        double d = Math.Round(db);//四舍五入取2位整数，但2.3却会只剩下2
                        if (tempStr[0] == '0')//如果第一位是零
                        {
                            amount.DecimalString = "0" + d.ToString();//就得在前面加个零，才能保持原来第一位是零
                        }
                        else
                        {
                            amount.DecimalString = d.ToString();//剔除小数点后保存
                        }
                    }
                    else//说明只有两位数或者1位数
                    {
                        amount.DecimalString = strArray[1];//就直接保存
                    }
                }
            }
            //以下处理整数部分
            if (amount.IntegerString.Length.ToString() == RangeLocation())
            {
                if (amount.IntegerString.StartsWith(WithZero()))//如果整数段的数字字符串开始匹配0
                {
                    amount.OutputAmount += ZTSM.ZTSMTools.Conversion.ConversionAmountDigital(WithZero(), ZTSM.Enumerations.AmountDigital.RMB)+Multiplier();
                    amount.IntegerString = amount.IntegerString.Substring(1);
                }else
                if (amount.IntegerString.StartsWith(WithOne()))//如果整数段的数字字符串的开始与1匹配
                {
                    amount.OutputAmount += Conversion.ConversionAmountDigital(WithOne(), AmountDigital.RMB)+Multiplier();//就输出大写的"壹"加金额单位如"仟"
                    amount.IntegerString = amount.IntegerString.Substring(1);//然后把整数字符串从头移除一位
                }else
                if (amount.IntegerString.StartsWith(WithTwo()))
                {
                    amount.OutputAmount += Conversion.ConversionAmountDigital(WithTwo(), AmountDigital.RMB) + Multiplier();
                    amount.IntegerString = amount.IntegerString.Substring(1);
                }else
                if (amount.IntegerString.StartsWith(WithThree()))
                {
                    amount.OutputAmount += Conversion.ConversionAmountDigital(WithThree(), AmountDigital.RMB) + Multiplier();
                    amount.IntegerString = amount.IntegerString.Substring(1);
                }else
                if (amount.IntegerString.StartsWith(WithFour()))
                {
                    amount.OutputAmount += Conversion.ConversionAmountDigital(WithFour(), AmountDigital.RMB) + Multiplier();
                    amount.IntegerString = amount.IntegerString.Substring(1);
                }else
                if (amount.IntegerString.StartsWith(WithFive()))
                {
                    amount.OutputAmount += Conversion.ConversionAmountDigital(WithFive(), AmountDigital.RMB) + Multiplier();
                    amount.IntegerString = amount.IntegerString.Substring(1);
                }else
                if (amount.IntegerString.StartsWith(WithSix()))
                {
                    amount.OutputAmount += Conversion.ConversionAmountDigital(WithSix(), AmountDigital.RMB) + Multiplier();
                    amount.IntegerString = amount.IntegerString.Substring(1);
                }else
                if (amount.IntegerString.StartsWith(WithSeven()))
                {
                    amount.OutputAmount += Conversion.ConversionAmountDigital(WithSeven(), AmountDigital.RMB) + Multiplier();
                    amount.IntegerString = amount.IntegerString.Substring(1);
                }else
                if (amount.IntegerString.StartsWith(WithEight()))
                {
                    amount.OutputAmount += Conversion.ConversionAmountDigital(WithEight(), AmountDigital.RMB) + Multiplier();
                    amount.IntegerString = amount.IntegerString.Substring(1);
                }else
                if (amount.IntegerString.StartsWith(WithNine()))
                {
                    amount.OutputAmount += Conversion.ConversionAmountDigital(WithNine(), AmountDigital.RMB) + Multiplier();
                    amount.IntegerString = amount.IntegerString.Substring(1);
                }

            }
            //以下处理小数部分
            if (!string.IsNullOrEmpty(amount.DecimalString))
            {
                if (amount.DecimalString.Length == (int.Parse(RangeLocation()) / 100))
                {
                    if (amount.DecimalString.StartsWith(WithZero()))
                    {
                        amount.OutputAmount += Conversion.ConversionAmountDigital(WithZero(), AmountDigital.RMB) + Multiplier();
                        amount.DecimalString = amount.DecimalString.Substring(1);
                    }else
                    if (amount.DecimalString.StartsWith(WithOne()))
                    {
                        amount.OutputAmount += Conversion.ConversionAmountDigital(WithOne(), AmountDigital.RMB) + Multiplier();
                        amount.DecimalString = amount.DecimalString.Substring(1);
                    }else
                    if (amount.DecimalString.StartsWith(WithTwo()))
                    {
                        amount.OutputAmount += Conversion.ConversionAmountDigital(WithTwo(), AmountDigital.RMB) + Multiplier();
                        amount.DecimalString = amount.DecimalString.Substring(1);
                    }else
                    if (amount.DecimalString.StartsWith(WithThree()))
                    {
                        amount.OutputAmount += Conversion.ConversionAmountDigital(WithThree(), AmountDigital.RMB) + Multiplier();
                        amount.DecimalString = amount.DecimalString.Substring(1);
                    }else
                    if (amount.DecimalString.StartsWith(WithFour()))
                    {
                        amount.OutputAmount += Conversion.ConversionAmountDigital(WithFour(), AmountDigital.RMB) + Multiplier();
                        amount.DecimalString = amount.DecimalString.Substring(1);
                    }else
                    if (amount.DecimalString.StartsWith(WithFive()))
                    {
                        amount.OutputAmount += Conversion.ConversionAmountDigital(WithFive(), AmountDigital.RMB) + Multiplier();
                        amount.DecimalString = amount.DecimalString.Substring(1);
                    }else
                    if (amount.DecimalString.StartsWith(WithSix()))
                    {
                        amount.OutputAmount += Conversion.ConversionAmountDigital(WithSix(), AmountDigital.RMB) + Multiplier();
                        amount.DecimalString = amount.DecimalString.Substring(1);
                    }else
                    if (amount.DecimalString.StartsWith(WithSeven()))
                    {
                        amount.OutputAmount += Conversion.ConversionAmountDigital(WithSeven(), AmountDigital.RMB) + Multiplier();
                        amount.DecimalString = amount.DecimalString.Substring(1);
                    }else
                    if (amount.DecimalString.StartsWith(WithEight()))
                    {
                        amount.OutputAmount += Conversion.ConversionAmountDigital(WithEight(), AmountDigital.RMB) + Multiplier();
                        amount.DecimalString = amount.DecimalString.Substring(1);
                    }else
                    if (amount.DecimalString.StartsWith(WithNine()))
                    {
                        amount.OutputAmount += Conversion.ConversionAmountDigital(WithNine(), AmountDigital.RMB) + Multiplier();
                        amount.DecimalString = amount.DecimalString.Substring(1);
                    }
                }
            }
        }

        #endregion
    }

Code
/// <summary>
    /// 千万亿类
    /// </summary>
    public class CnQianWanYi : ZTSM.Auxiliary.CnCapitalAmount
    {
        public  override string Multiplier()
        {
            return "仟";
        }
        public  override string RangeLocation()
        {
            return "16";
        }
    }
    /// <summary>
    /// 百万亿类
    /// </summary>
    public class CnBaiWanYi : ZTSM.Auxiliary.CnCapitalAmount
    {
        public override string Multiplier()
        {
            return "佰";
        }
        public override string RangeLocation()
        {
            return "15";
        }
    }
    /// <summary>
    /// 十万亿类
    /// </summary>
    public class CnShiWanYi : ZTSM.Auxiliary.CnCapitalAmount
    {
        public override string Multiplier()
        {
            return "拾";
        }
        public override string RangeLocation()
        {
            return "14";
        }
    }
    /// <summary>
    /// 万亿类
    /// </summary>
    public class CnWanYi : ZTSM.Auxiliary.CnCapitalAmount
    {
        public override string Multiplier()
        {
            return "万";
        }
        public override string RangeLocation()
        {
            return "13";
        }
    }
    /// <summary>
    /// 千亿类
    /// </summary>
    public class CnQianYi : ZTSM.Auxiliary.CnCapitalAmount
    {
        public override string Multiplier()
        {
            return "仟";
        }
        public override string RangeLocation()
        {
            return "12";
        }
    }
    /// <summary>
    /// 佰亿类
    /// </summary>
    public class CnBaiYi : ZTSM.Auxiliary.CnCapitalAmount
    {
        public override string Multiplier()
        {
            return "佰";
        }
        public override string RangeLocation()
        {
            return "11";
        }
    }
    /// <summary>
    /// 十亿类
    /// </summary>
    public class CnShiYi : ZTSM.Auxiliary.CnCapitalAmount
    {
        public override string Multiplier()
        {
            return "拾";
        }
        public override string RangeLocation()
        {
            return "10";
        }
    }
    /// <summary>
    /// 亿类
    /// </summary>
    public class CnYi : ZTSM.Auxiliary.CnCapitalAmount
    {
        public override string Multiplier()
        {
            return "亿";
        }
        public override string RangeLocation()
        {
            return "9";
        }
    }
    /// <summary>
    /// 千万类
    /// </summary>
    public class CnQianWan : ZTSM.Auxiliary.CnCapitalAmount
    {
        public override string Multiplier()
        {
            return "仟";
        }
        public override string RangeLocation()
        {
            return "8";
        }
    }
    /// <summary>
    /// 百万类
    /// </summary>
    public class CnBaiWan : ZTSM.Auxiliary.CnCapitalAmount
    {
        public override string Multiplier()
        {
            return "佰";
        }
        public override string RangeLocation()
        {
            return "7";
        }
    }
    /// <summary>
    /// 十万类
    /// </summary>
    public class CnShiWan : ZTSM.Auxiliary.CnCapitalAmount
    {
        public override string Multiplier()
        {
            return "拾";
        }
        public override string RangeLocation()
        {
            return "6";
        }
    }
    /// <summary>
    /// 万类
    /// </summary>
    public class CnWan : ZTSM.Auxiliary.CnCapitalAmount
    {
        public override string Multiplier()
        {
            return "万";
        }
        public override string RangeLocation()
        {
            return "5";
        }
    }
    /// <summary>
    /// 仟类
    /// </summary>
    public class CnQian : ZTSM.Auxiliary.CnCapitalAmount
    {
        public override string Multiplier()
        {
            return "仟";
        }
        public override string RangeLocation()
        {
            return "4";
        }
    }
    /// <summary>
    /// 佰类
    /// </summary>
    public class CnBai : ZTSM.Auxiliary.CnCapitalAmount
    {
        public override string Multiplier()
        {
            return "佰";
        }
        public override string RangeLocation()
        {
            return "3";
        }
    }
    /// <summary>
    /// 拾类
    /// </summary>
    public class CnShi : ZTSM.Auxiliary.CnCapitalAmount
    {
        public override string Multiplier()
        {
            return "拾";
        }
        public override string RangeLocation()
        {
            return "2";
        }
    }
    /// <summary>
    /// 圆类
    /// </summary>
    public class CnYuan : ZTSM.Auxiliary.CnCapitalAmount
    {
        public override string Multiplier()
        {
            return "圆";
        }
        public override string RangeLocation()
        {
            return "1";
        }
    }
    /// <summary>
    /// 角类
    /// </summary>
    public class CnJiao : ZTSM.Auxiliary.CnCapitalAmount
    {
        public override string Multiplier()
        {
            return "角";
        }
        public override string RangeLocation()
        {
            return "200";
        }

    }
    /// <summary>
    /// 分类
    /// </summary>
    public class CnFen : ZTSM.Auxiliary.CnCapitalAmount
    {
        public override string Multiplier()
        {
            return "分";
        }
        public override string RangeLocation()
        {
            return "100";
        }
    }
}

Code
namespace ZTSM.Auxiliary
{
    /// <summary>
    ///将中文大写金额转换为阿拉伯数字小写金额的类
    /// </summary>
    public abstract class AlbLowerAmount:ZTSM.Interfaces.IAmountConversion
    {

        #region IAmountConversion 成员

        public  string WithZero()
        {
            return "";
        }
        /// <summary>
        /// 返回壹
        /// </summary>
        /// <returns></returns>
        public string WithOne()
        {
            return "壹" ;
        }
        /// <summary>
        /// 返回贰
        /// </summary>
        /// <returns></returns>
        public string WithTwo()
        {
            return "贰" ;
        }
        /// <summary>
        /// 返回叁
        /// </summary>
        /// <returns></returns>
        public string WithThree()
        {
            return "叁" ;
        }
        /// <summary>
        /// 返回肆
        /// </summary>
        /// <returns></returns>
        public string WithFour()
        {
            return "肆" ;
        }
        /// <summary>
        /// 返回伍
        /// </summary>
        /// <returns></returns>
        public string WithFive()
        {
            return "伍" ;
        }
        /// <summary>
        /// 返回陆
        /// </summary>
        /// <returns></returns>
        public string WithSix()
        {
            return "陆" ;
        }
        /// <summary>
        /// 返回柒
        /// </summary>
        /// <returns></returns>
        public string WithSeven()
        {
            return "柒" ;
        }
        /// <summary>
        /// 返回捌
        /// </summary>
        /// <returns></returns>
        public string WithEight()
        {
            return "捌" ;
        }
        /// <summary>
        /// 返回玖
        /// </summary>
        /// <returns></returns>
        public string WithNine()
        {
            return "玖" ;
        }
        /// <summary>
        /// 返回金额单位标识字，如仟
        /// </summary>
        /// <returns></returns>
        public virtual  string RangeLocation()
        {
            return null ;
        }
        /// <summary>
        /// 返回本段位的乘积数，如仟为 1000
        /// </summary>
        /// <returns></returns>
        public virtual  string Multiplier()
        {
            return null ;
        }
        /// <summary>
        /// 兆单位的基本值 1000000000000
        /// </summary>
        /// <returns></returns>
        private decimal  ZhaoUnitBase()
        {
            return 1000000000000;
        }
        /// <summary>
        /// 亿单位的基本值 100000000
        /// </summary>
        /// <returns></returns>
        protected decimal YiUnitBase()
        {
            return 100000000;
        }
        /// <summary>
        /// 万单位的基本值 10000
        /// </summary>
        /// <returns></returns>
        protected decimal WanUnitBase()
        {
            return 10000;
        }
        public void Interpret(ZTSM.Entity.Amount amount)
        {
            if (string.IsNullOrEmpty(amount.InputAmount))
            {
                amount.OutputAmount = "无法转换空的金额";
                return;
            }
            if (Validations.IsNotAmountCharacter(amount.InputAmount))
            {
                amount.OutputAmount = "你输入有非中文金额字符。请更正输入。";
                return;
            }
            amount.InputAmount = ZTSM.ZTSMTools.Conversion.CnStandardsAmountUnitConversion(amount.InputAmount);//把不标准的金额单位如千转换为仟
            amount.InputAmount = ZTSM.ZTSMTools.Conversion.TrillionAmountUnit(amount.InputAmount, "万", "兆");//把万亿的万转换为兆
            string patt = @"\w[零壹贰叁肆伍陆柒捌玖]仟[零壹贰叁肆伍陆柒捌玖]?佰?[零壹贰叁肆伍陆柒捌玖]?拾?[零壹贰叁肆伍陆柒捌玖]?兆";
            System.Text.RegularExpressions.Match m = System.Text.RegularExpressions.Regex.Match(amount.InputAmount, patt);//正则表达式检查长度
            if (m.Success)//如果匹配，说明超过兆
            {
                amount.OutputAmount = "无法转换大于千兆的金额";
                return;
            }
            amount.InputAmount = amount.InputAmount.Replace("零", "");//把零字去掉
            //下面处理兆段位
            ProcessingZhaoParagraph(amount);
            //下面处理亿段位
            ProcessingYiParagraph(amount);
            //下面处理万位段
            ProcessingWanParagraph(amount);
            //下面处理圆位段
            ProcessingYuanParagraph(amount);
            //下面处理角与分位段
            ProcessingJiaoFenParagraph(amount);
        }
        /// <summary>
        /// 处理亿位段
        /// </summary>
        /// <param name="amount"></param>
        private void ProcessingYiParagraph(ZTSM.Entity.Amount amount)
        {
            if (amount.InputAmount.Contains("亿"))
            {
                if (string.IsNullOrEmpty(amount.YiString))
                {
                    if (amount.InputAmount.Contains("兆"))
                    {
                        amount.YiString = amount.InputAmount.Substring(amount.InputAmount.IndexOf("兆") + 1, amount.InputAmount.IndexOf("亿") - amount.InputAmount.IndexOf("兆"));//取兆至亿之间的文字段如：叁拾贰兆叁仟叁佰叁拾叁亿，取叁仟叁佰叁拾叁亿
                    }
                    else
                    {
                        amount.YiString = amount.InputAmount.Substring(0, amount.InputAmount.IndexOf("亿") + 1);
                    }
                }
                if (amount.YiString.StartsWith(WithOne() + RangeLocation()))
                {
                    amount.OutNumberAmount += Int32.Parse(Conversion.ConversionAmountDigital(WithOne(), AmountDigital.ALB)) * Int32.Parse(Multiplier()) * YiUnitBase();
                    amount.YiString = amount.YiString.Substring(2);
                }else
                if (amount.YiString.StartsWith(WithTwo() + RangeLocation()))
                {
                    amount.OutNumberAmount += Int32.Parse(Conversion.ConversionAmountDigital(WithTwo(), AmountDigital.ALB)) * Int32.Parse(Multiplier()) * YiUnitBase();
                    amount.YiString = amount.YiString.Substring(2);
                }else
                if (amount.YiString.StartsWith(WithThree() + RangeLocation()))
                {
                    amount.OutNumberAmount += Int32.Parse(Conversion.ConversionAmountDigital(WithThree(), AmountDigital.ALB)) * Int32.Parse(Multiplier()) * YiUnitBase();
                    amount.YiString = amount.YiString.Substring(2);
                }else
                if (amount.YiString.StartsWith(WithFour() + RangeLocation()))
                {
                    amount.OutNumberAmount += Int32.Parse(Conversion.ConversionAmountDigital(WithFour(), AmountDigital.ALB)) * Int32.Parse(Multiplier()) * YiUnitBase();
                    amount.YiString = amount.YiString.Substring(2);
                }else
                if (amount.YiString.StartsWith(WithFive() + RangeLocation()))
                {
                    amount.OutNumberAmount += Int32.Parse(Conversion.ConversionAmountDigital(WithFive(), AmountDigital.ALB)) * Int32.Parse(Multiplier()) * YiUnitBase();
                    amount.YiString = amount.YiString.Substring(2);
                }else
                if (amount.YiString.StartsWith(WithSix() + RangeLocation()))
                {
                    amount.OutNumberAmount += Int32.Parse(Conversion.ConversionAmountDigital(WithSix(), AmountDigital.ALB)) * Int32.Parse(Multiplier()) * YiUnitBase();
                    amount.YiString = amount.YiString.Substring(2);
                }else
                if (amount.YiString.StartsWith(WithSeven() + RangeLocation()))
                {
                    amount.OutNumberAmount += Int32.Parse(Conversion.ConversionAmountDigital(WithSeven(), AmountDigital.ALB)) * Int32.Parse(Multiplier()) * YiUnitBase();
                    amount.YiString = amount.YiString.Substring(2);
                }else
                if (amount.YiString.StartsWith(WithEight() + RangeLocation()))
                {
                    amount.OutNumberAmount += Int32.Parse(Conversion.ConversionAmountDigital(WithEight(), AmountDigital.ALB)) * Int32.Parse(Multiplier()) * YiUnitBase();
                    amount.YiString = amount.YiString.Substring(2);
                }else
                if (amount.YiString.StartsWith(WithNine() + RangeLocation()))
                {
                    amount.OutNumberAmount += Int32.Parse(Conversion.ConversionAmountDigital(WithNine(), AmountDigital.ALB)) * Int32.Parse(Multiplier()) * YiUnitBase();
                    amount.YiString = amount.YiString.Substring(2);
                }

            }
        }
        /// <summary>
        /// 处理兆位段
        /// </summary>
        /// <param name="amount"></param>
        private void ProcessingZhaoParagraph(ZTSM.Entity.Amount amount)
        {
            if (amount.InputAmount.Contains("兆"))
            {
                if (string.IsNullOrEmpty(amount.ZhaoString))
                {
                    amount.ZhaoString = amount.InputAmount.Substring(0, amount.InputAmount.IndexOf("兆") + 1);
                }
                if (amount.ZhaoString.StartsWith(WithOne() + RangeLocation()))
                {
                    amount.OutNumberAmount += Int32.Parse(Conversion.ConversionAmountDigital(WithOne(), AmountDigital.ALB)) * Int32.Parse(Multiplier()) * ZhaoUnitBase();
                    amount.ZhaoString = amount.ZhaoString.Substring(2);
                }else
                if (amount.ZhaoString.StartsWith(WithTwo() + RangeLocation()))
                {
                    amount.OutNumberAmount += Int32.Parse(Conversion.ConversionAmountDigital(WithTwo(), AmountDigital.ALB)) * Int32.Parse(Multiplier()) * ZhaoUnitBase();
                    amount.ZhaoString = amount.ZhaoString.Substring(2);
                }else
                if (amount.ZhaoString.StartsWith(WithThree() + RangeLocation()))
                {
                    amount.OutNumberAmount += Int32.Parse(Conversion.ConversionAmountDigital(WithThree(), AmountDigital.ALB)) * Int32.Parse(Multiplier()) * ZhaoUnitBase();
                    amount.ZhaoString = amount.ZhaoString.Substring(2);
                }else
                if (amount.ZhaoString.StartsWith(WithFour() + RangeLocation()))
                {
                    amount.OutNumberAmount += Int32.Parse(Conversion.ConversionAmountDigital(WithFour(), AmountDigital.ALB)) * Int32.Parse(Multiplier()) * ZhaoUnitBase();
                    amount.ZhaoString = amount.ZhaoString.Substring(2);
                }else
                if (amount.ZhaoString.StartsWith(WithFive() + RangeLocation()))
                {
                    amount.OutNumberAmount += Int32.Parse(Conversion.ConversionAmountDigital(WithFive(), AmountDigital.ALB)) * Int32.Parse(Multiplier()) * ZhaoUnitBase();
                    amount.ZhaoString = amount.ZhaoString.Substring(2);
                }else
                if (amount.ZhaoString.StartsWith(WithSix() + RangeLocation()))
                {
                    amount.OutNumberAmount += Int32.Parse(Conversion.ConversionAmountDigital(WithSix(), AmountDigital.ALB)) * Int32.Parse(Multiplier()) * ZhaoUnitBase();
                    amount.ZhaoString = amount.ZhaoString.Substring(2);
                }else
                if (amount.ZhaoString.StartsWith(WithSeven() + RangeLocation()))
                {
                    amount.OutNumberAmount += Int32.Parse(Conversion.ConversionAmountDigital(WithSeven(), AmountDigital.ALB)) * Int32.Parse(Multiplier()) * ZhaoUnitBase();
                    amount.ZhaoString = amount.ZhaoString.Substring(2);
                }else
                if (amount.ZhaoString.StartsWith(WithEight() + RangeLocation()))
                {
                    amount.OutNumberAmount += Int32.Parse(Conversion.ConversionAmountDigital(WithEight(), AmountDigital.ALB)) * Int32.Parse(Multiplier()) * ZhaoUnitBase();
                    amount.ZhaoString = amount.ZhaoString.Substring(2);
                }else
                if (amount.ZhaoString.StartsWith(WithNine() + RangeLocation()))
                {
                    amount.OutNumberAmount += Int32.Parse(Conversion.ConversionAmountDigital(WithNine(), AmountDigital.ALB)) * Int32.Parse(Multiplier()) * ZhaoUnitBase();
                    amount.ZhaoString = amount.ZhaoString.Substring(2);
                }
            }
        }
        /// <summary>
        /// 处理万位段
        /// </summary>
        /// <param name="amount"></param>
        private void ProcessingWanParagraph(ZTSM.Entity.Amount amount)
        {
            if (amount.InputAmount.Contains("万"))
            {
                if (string.IsNullOrEmpty(amount.WanString))
                {
                    if (amount.InputAmount.Contains("亿"))
                    {
                        amount.WanString = amount.InputAmount.Substring(amount.InputAmount.IndexOf("亿") + 1, amount.InputAmount.IndexOf("万") - amount.InputAmount.IndexOf("亿"));
                    }
                    else
                    {
                        amount.WanString = amount.InputAmount.Substring(0, amount.InputAmount.IndexOf("万") + 1);
                    }
                }
                if (amount.WanString.StartsWith(WithOne() + RangeLocation()))
                {
                    amount.OutNumberAmount += Int32.Parse(Conversion.ConversionAmountDigital(WithOne(), AmountDigital.ALB)) * Int32.Parse(Multiplier()) * WanUnitBase();
                    amount.WanString = amount.WanString.Substring(2);
                }else
                if (amount.WanString.StartsWith(WithTwo() + RangeLocation()))
                {
                    amount.OutNumberAmount += Int32.Parse(Conversion.ConversionAmountDigital(WithTwo(), AmountDigital.ALB)) * Int32.Parse(Multiplier()) * WanUnitBase();
                    amount.WanString = amount.WanString.Substring(2);
                }else
                if (amount.WanString.StartsWith(WithThree() + RangeLocation()))
                {
                    amount.OutNumberAmount += Int32.Parse(Conversion.ConversionAmountDigital(WithThree(), AmountDigital.ALB)) * Int32.Parse(Multiplier()) * WanUnitBase();
                    amount.WanString = amount.WanString.Substring(2);
                }else
                if (amount.WanString.StartsWith(WithFour() + RangeLocation()))
                {
                    amount.OutNumberAmount += Int32.Parse(Conversion.ConversionAmountDigital(WithFour(), AmountDigital.ALB)) * Int32.Parse(Multiplier()) * WanUnitBase();
                    amount.WanString = amount.WanString.Substring(2);
                }else
                if (amount.WanString.StartsWith(WithFive() + RangeLocation()))
                {
                    amount.OutNumberAmount += Int32.Parse(Conversion.ConversionAmountDigital(WithFive(), AmountDigital.ALB)) * Int32.Parse(Multiplier()) * WanUnitBase();
                    amount.WanString = amount.WanString.Substring(2);
                }else
                if (amount.WanString.StartsWith(WithSix() + RangeLocation()))
                {
                    amount.OutNumberAmount += Int32.Parse(Conversion.ConversionAmountDigital(WithSix(), AmountDigital.ALB)) * Int32.Parse(Multiplier()) * WanUnitBase();
                    amount.WanString = amount.WanString.Substring(2);
                }else
                if (amount.WanString.StartsWith(WithSeven() + RangeLocation()))
                {
                    amount.OutNumberAmount += Int32.Parse(Conversion.ConversionAmountDigital(WithSeven(), AmountDigital.ALB)) * Int32.Parse(Multiplier()) * WanUnitBase();
                    amount.WanString = amount.WanString.Substring(2);
                }else
                if (amount.WanString.StartsWith(WithEight() + RangeLocation()))
                {
                    amount.OutNumberAmount += Int32.Parse(Conversion.ConversionAmountDigital(WithEight(), AmountDigital.ALB)) * Int32.Parse(Multiplier()) * WanUnitBase();
                    amount.WanString = amount.WanString.Substring(2);
                }else
                if (amount.WanString.StartsWith(WithNine() + RangeLocation()))
                {
                    amount.OutNumberAmount += Int32.Parse(Conversion.ConversionAmountDigital(WithNine(), AmountDigital.ALB)) * Int32.Parse(Multiplier()) * WanUnitBase();
                    amount.WanString = amount.WanString.Substring(2);
                }
            }
        }
        /// <summary>
        /// 处理圆位段
        /// </summary>
        /// <param name="amount"></param>
        private void ProcessingYuanParagraph(ZTSM.Entity.Amount amount)
        {
            if (amount.InputAmount.Contains("圆"))
            {
                if (string.IsNullOrEmpty(amount.YuanString))
                {
                    if (amount.InputAmount.Contains("万"))
                    {
                        amount.YuanString = amount.InputAmount.Substring(amount.InputAmount.IndexOf("万") + 1, amount.InputAmount.IndexOf("圆") - amount.InputAmount.IndexOf("万"));
                    }
                    else if (amount.InputAmount.Contains("亿"))
                    {
                        amount.YuanString = amount.InputAmount.Substring(amount.InputAmount.IndexOf("亿") + 1, amount.InputAmount.IndexOf("圆") - amount.InputAmount.IndexOf("亿"));
                    }
                    else
                    {
                        amount.YuanString = amount.InputAmount.Substring(0, amount.InputAmount.IndexOf("圆") + 1);
                    }
                }
                if (amount.YuanString.StartsWith(WithOne() + RangeLocation()))
                {
                    amount.OutNumberAmount += Int32.Parse(Conversion.ConversionAmountDigital(WithOne(), AmountDigital.ALB)) * Int32.Parse(Multiplier());
                    amount.YuanString = amount.YuanString.Substring(2);
                }else
                if (amount.YuanString.StartsWith(WithTwo() + RangeLocation()))
                {
                    amount.OutNumberAmount += Int32.Parse(Conversion.ConversionAmountDigital(WithTwo(), AmountDigital.ALB)) * Int32.Parse(Multiplier());
                    amount.YuanString = amount.YuanString.Substring(2);
                }else
                if (amount.YuanString.StartsWith(WithThree() + RangeLocation()))
                {
                    amount.OutNumberAmount += Int32.Parse(Conversion.ConversionAmountDigital(WithThree(), AmountDigital.ALB)) * Int32.Parse(Multiplier());
                    amount.YuanString = amount.YuanString.Substring(2);
                }else
                if (amount.YuanString.StartsWith(WithFour() + RangeLocation()))
                {
                    amount.OutNumberAmount += Int32.Parse(Conversion.ConversionAmountDigital(WithFour(), AmountDigital.ALB)) * Int32.Parse(Multiplier());
                    amount.YuanString = amount.YuanString.Substring(2);
                }else
                if (amount.YuanString.StartsWith(WithFive() + RangeLocation()))
                {
                    amount.OutNumberAmount += Int32.Parse(Conversion.ConversionAmountDigital(WithFive(), AmountDigital.ALB)) * Int32.Parse(Multiplier());
                    amount.YuanString = amount.YuanString.Substring(2);
                }else
                if (amount.YuanString.StartsWith(WithSix() + RangeLocation()))
                {
                    amount.OutNumberAmount += Int32.Parse(Conversion.ConversionAmountDigital(WithSix(), AmountDigital.ALB)) * Int32.Parse(Multiplier());
                    amount.YuanString = amount.YuanString.Substring(2);
                }else
                if (amount.YuanString.StartsWith(WithSeven() + RangeLocation()))
                {
                    amount.OutNumberAmount += Int32.Parse(Conversion.ConversionAmountDigital(WithSeven(), AmountDigital.ALB)) * Int32.Parse(Multiplier());
                    amount.YuanString = amount.YuanString.Substring(2);
                }else
                if (amount.YuanString.StartsWith(WithEight() + RangeLocation()))
                {
                    amount.OutNumberAmount += Int32.Parse(Conversion.ConversionAmountDigital(WithEight(), AmountDigital.ALB)) * Int32.Parse(Multiplier());
                    amount.YuanString = amount.YuanString.Substring(2);
                }else
                if (amount.YuanString.StartsWith(WithNine() + RangeLocation()))
                {
                    amount.OutNumberAmount += Int32.Parse(Conversion.ConversionAmountDigital(WithNine(), AmountDigital.ALB)) * Int32.Parse(Multiplier());
                    amount.YuanString = amount.YuanString.Substring(2);
                }
            }
        }
        /// <summary>
        /// 处理角分位段
        /// </summary>
        /// <param name="amount"></param>
        private void ProcessingJiaoFenParagraph(ZTSM.Entity.Amount amount)
        {
            if (amount.InputAmount.Contains("角") || amount.InputAmount.Contains("分"))
            {
                if (string.IsNullOrEmpty(amount.JiaoFenString))
                {
                    if (amount.InputAmount.Contains("圆"))
                    {
                        amount.JiaoFenString = amount.InputAmount.Substring(amount.InputAmount.IndexOf("圆") + 1);
                    }
                    else
                    {
                        amount.JiaoFenString = amount.InputAmount;
                    }
                }
                if (amount.JiaoFenString.StartsWith(WithOne() + RangeLocation()))
                {
                    amount.OutNumberAmount += Int32.Parse(Conversion.ConversionAmountDigital(WithOne(), AmountDigital.ALB)) * decimal.Parse(Multiplier());
                    amount.JiaoFenString = amount.JiaoFenString.Substring(2);
                }else
                if (amount.JiaoFenString.StartsWith(WithTwo() + RangeLocation()))
                {
                    amount.OutNumberAmount += Int32.Parse(Conversion.ConversionAmountDigital(WithTwo(), AmountDigital.ALB)) * decimal.Parse(Multiplier());
                    amount.JiaoFenString = amount.JiaoFenString.Substring(2);
                }else
                if (amount.JiaoFenString.StartsWith(WithThree() + RangeLocation()))
                {
                    amount.OutNumberAmount += Int32.Parse(Conversion.ConversionAmountDigital(WithThree(), AmountDigital.ALB)) * decimal.Parse(Multiplier());
                    amount.JiaoFenString = amount.JiaoFenString.Substring(2);
                }else
                if (amount.JiaoFenString.StartsWith(WithFour() + RangeLocation()))
                {
                    amount.OutNumberAmount += Int32.Parse(Conversion.ConversionAmountDigital(WithFour(), AmountDigital.ALB)) * decimal.Parse(Multiplier());
                    amount.JiaoFenString = amount.JiaoFenString.Substring(2);
                }else
                if (amount.JiaoFenString.StartsWith(WithFive() + RangeLocation()))
                {
                    amount.OutNumberAmount += Int32.Parse(Conversion.ConversionAmountDigital(WithFive(), AmountDigital.ALB)) * decimal.Parse(Multiplier());
                    amount.JiaoFenString = amount.JiaoFenString.Substring(2);
                }else
                if (amount.JiaoFenString.StartsWith(WithSix() + RangeLocation()))
                {
                    amount.OutNumberAmount += Int32.Parse(Conversion.ConversionAmountDigital(WithSix(), AmountDigital.ALB)) * decimal.Parse(Multiplier());
                    amount.JiaoFenString = amount.JiaoFenString.Substring(2);
                }else
                if (amount.JiaoFenString.StartsWith(WithSeven() + RangeLocation()))
                {
                    amount.OutNumberAmount += Int32.Parse(Conversion.ConversionAmountDigital(WithSeven(), AmountDigital.ALB)) * decimal.Parse(Multiplier());
                    amount.JiaoFenString = amount.JiaoFenString.Substring(2);
                }else
                if (amount.JiaoFenString.StartsWith(WithEight() + RangeLocation()))
                {
                    amount.OutNumberAmount += Int32.Parse(Conversion.ConversionAmountDigital(WithEight(), AmountDigital.ALB)) * decimal.Parse(Multiplier());
                    amount.JiaoFenString = amount.JiaoFenString.Substring(2);
                }else
                if (amount.JiaoFenString.StartsWith(WithNine() + RangeLocation()))
                {
                    amount.OutNumberAmount += Int32.Parse(Conversion.ConversionAmountDigital(WithNine(), AmountDigital.ALB)) *decimal.Parse(Multiplier());
                    amount.JiaoFenString = amount.JiaoFenString.Substring(2);
                }
            }
        }
        #endregion
    }

Code
/// <summary>
    /// 仟位类
    /// </summary>
    public class AlbQian : ZTSM.Auxiliary.AlbLowerAmount
    {

        public override string RangeLocation()
        {
            return "仟";
        }
        public override string Multiplier()
        {
            return "1000";
        }
    }
    /// <summary>
    /// 百位类
    /// </summary>
    public class AlbBai : ZTSM.Auxiliary.AlbLowerAmount
    {
        public override string RangeLocation()
        {
            return "佰";
        }
        public override string Multiplier()
        {
            return "100";
        }

    }
    /// <summary>
    /// 十位类
    /// </summary>
    public class AlbShi : ZTSM.Auxiliary.AlbLowerAmount
    {
        public override string RangeLocation()
        {
            return "拾";
        }
        public override string Multiplier()
        {
            return "10";
        }
    }
    /// <summary>
    /// 兆位类
    /// </summary>
    public class AlbZhao : ZTSM.Auxiliary.AlbLowerAmount
    {
        public override string RangeLocation()
        {
            return "兆";
        }
        public override string Multiplier()
        {
            return "1";
        }
    }
    /// <summary>
    /// 亿位类
    /// </summary>
    public class AlbYi : ZTSM.Auxiliary.AlbLowerAmount
    {
        public override string RangeLocation()
        {
            return "亿";
        }
        public override string Multiplier()
        {
            return "1";
        }
    }
    /// <summary>
    /// 万位类
    /// </summary>
    public class AlbWan : ZTSM.Auxiliary.AlbLowerAmount
    {
        public override string RangeLocation()
        {
            return "万";
        }
        public override string Multiplier()
        {
            return "1";
        }
    }
    /// <summary>
    /// 圆位类
    /// </summary>
    public class AlbYuan : ZTSM.Auxiliary.AlbLowerAmount
    {
        public override string RangeLocation()
        {
            return "圆";
        }
        public override string Multiplier()
        {
            return "1";
        }
    }
    /// <summary>
    /// 角位类
    /// </summary>
    public class AlbJiao : ZTSM.Auxiliary.AlbLowerAmount
    {
        public override string RangeLocation()
        {
            return "角";
        }
        public override string Multiplier()
        {
            return "0.1";
        }
    }
    /// <summary>
    /// 分位类
    /// </summary>
    public class AlbFen : ZTSM.Auxiliary.AlbLowerAmount
    {
        public override string RangeLocation()
        {
            return "分";
        }
        public override string Multiplier()
        {
            return "0.01";
        }
    }
}

Code
namespace ZTSM.Entity
{
    /// <summary>
    ///金额实体类
    /// </summary>
    public class Amount
    {
        string inputAmount;
        string outputAmount;
        decimal outNumberAmount;
        string integerString;
        string  decimalString;
        /// <summary>
        /// 用输入金额数字实例化金额类
        /// </summary>
        /// <param name="inputAmount">中文或者阿拉伯金额数字</param>
        public Amount(string inputAmount)
        {
            this.inputAmount = inputAmount;
        }
        /// <summary>
        /// 保存输入金额的属性
        /// </summary>
        public string InputAmount
        {
            get
            {
                return inputAmount;
            }
            set
            {
                inputAmount = value;
            }
        }
        /// <summary>
        /// 保存输出中文金额的属性
        /// </summary>
        public string OutputAmount
        {
            get
            {
                return outputAmount;
            }
            set
            {
                outputAmount = value;
            }
        }
        /// <summary>
        /// 保存输出数字金额的属性
        /// </summary>
        public decimal OutNumberAmount
        {
            get
            {
                return outNumberAmount;
            }
            set
            {
                outNumberAmount = value;
            }
        }
        /// <summary>
        /// 保存数字金额字符串的整数部分的属性
        /// </summary>
        public string IntegerString
        {
            get
            {
                return integerString;
            }
            set
            {
                integerString = value;
            }
        }
        /// <summary>
        /// 保存数字金额字符串的小数部分的属性
        /// </summary>
        public string DecimalString
        {
            get
            {
                return decimalString;
            }
            set
            {
                decimalString = value;
            }
        }
        string yiString;
        /// <summary>
        /// 保存亿位段的金额字符串
        /// </summary>
        public string YiString
        {
            get
            {
                return yiString;
            }
            set
            {
                yiString = value;
            }
        }
        string  wanString;
        /// <summary>
        /// 保存万位段的金额字符串
        /// </summary>
        public string WanString
        {
            get
            {
                return wanString;
            }
            set
            {
                wanString = value;
            }
        }
        string yuanString;
        /// <summary>
        /// 保存元位段的金额字符串
        /// </summary>
        public string YuanString
        {
            get
            {
                return yuanString;
            }
            set
            {
                yuanString = value;
            }
        }
        string jiaoFenString;
        /// <summary>
        /// 保存角和分位段的金额字符串
        /// </summary>
        public string JiaoFenString
        {
            get
            {
                return jiaoFenString;
            }
            set
            {
                jiaoFenString = value;
            }
        }
        string zhaoString;
        /// <summary>
        /// 保存兆段位的金额字符串
        /// </summary>
        public string ZhaoString
        {
            get
            {
                return zhaoString;
            }
            set
            {
                zhaoString = value;
            }
        }

    }
}

Code
namespace ZTSM.ZTSMTools
{
    public class Validations
    {
        /// <summary>
        /// 指示是否是数字
        /// </summary>
        /// <param name="chars">数字类型的字符串</param>
        /// <returns>布尔值</returns>
        public static bool IsDigital(string numberString)
        {
            bool b = true;

            if (string.IsNullOrEmpty(numberString))
            {
                return b = false;
            }
            for (int i = 0; i < numberString.Length; i++)
            {
                if (!char.IsNumber(numberString , i))
                {
                    b = false;
                    break;
                }
            }
            return b;
        }
        /// <summary>
        /// 检查是否存在非中文金额字符
        /// </summary>
        /// <param name="inputString">输入的金额字符串</param>
        /// <returns>true:说明有非金额字符;false:说明是金额字符</returns>
        public static bool IsNotAmountCharacter(string inputString)
        {
            string patt = "[^零壹贰叁肆伍陆柒捌玖兆亿万仟佰拾圆元角分億千百十]+";
            return  System.Text.RegularExpressions.Regex.IsMatch(inputString, patt);
        }

    }

}

namespace ZTSM.ZTSMTools
{
    public class Conversion
    {
        /// <summary>
        /// 转换金额数字
        /// </summary>
        /// <param name="amountNumber">单个的大写金额数字或小写金额数字(如 "贰" 或 "2" )</param>
        /// <param name="amountDigital">指示是要转换为中文大写还是阿拉伯数字形式的小写</param>
        /// <returns>返回转换后的金额数字</returns>
        public static string ConversionAmountDigital(string amountNumber, ZTSM.Enumerations.AmountDigital amountDigital)
        {
            string strCn = "零壹贰叁肆伍陆柒捌玖";
            string strAlb = "0123456789";
            string tempNum = "无法识别的金额数字。是否输入有误?请输入正确的大写或小写金额数字";
            if (amountDigital == ZTSM.Enumerations.AmountDigital.RMB)
            {
                for (int i = 0; i < strAlb.Length; i++)
                {
                    if (strAlb[i].ToString() == amountNumber)
                    {
                        tempNum = strCn[i].ToString();
                        break;
                    }
                }
            }
            else if (amountDigital == ZTSM.Enumerations.AmountDigital.ALB)
            {
                for (int i = 0; i < strCn.Length; i++)
                {
                    if (strCn[i].ToString() == amountNumber)
                    {
                        tempNum = strAlb[i].ToString();
                        break;
                    }
                }
            }
            return tempNum;

        }
        /// <summary>
        /// 移除大写金额字符串中重复的零，以保证大写金额正确的读写格式
        /// </summary>
        /// <param name="amountString">格式化前的大写金额字符串</param>
        /// <returns>格式后的大写金额字符串</returns>
        public static string RemoveZeroAmountString(string amountString)
        {
            amountString = amountString.Replace("零仟", "零");
            amountString = amountString.Replace("零佰", "零");
            amountString = amountString.Replace("零拾", "零");

            amountString = amountString.Replace("零零零零", "");
            amountString = amountString.Replace("零零零", "零");
            amountString = amountString.Replace("零零", "零");

            amountString = amountString.Replace("零亿", "亿");

            amountString = amountString.Replace("零万", "万");

            amountString = amountString.Replace("零圆", "圆");

            amountString = amountString.Replace("零角", "零");
            amountString = amountString.Replace("零零分", "整");
            amountString = amountString.Replace("角零分", "角整");
            if (amountString.EndsWith("圆"))
            {
                amountString = amountString + "整";
            }
            return amountString;
        }
        /// <summary>
        /// 移除数字的小数点符号
        /// </summary>
        /// <param name="s">包含小数点的数字字符串</param>
        /// <returns>剔除小数点后的数字字符串</returns>
        public static string RemoveDecimalSymbol(string decimalSymbolString)
        {
            if (decimalSymbolString.IndexOf('.') < 0)
            {
                return decimalSymbolString;
            }
            string[] strs = decimalSymbolString.Split('.');
            string newstr = null;
            foreach (string c in strs)
            {
                newstr += c;
            }
            return newstr;
        }
        /// <summary>
        /// 将不标准的中文金额单位(如元、億)转换为标准的中文金额单位如(圆、亿)
        /// </summary>
        /// <param name="cnAmountString">不标准的金额串</param>
        /// <returns>标准的金额串</returns>
        public static string CnStandardsAmountUnitConversion(string cnAmountString)
        {
            cnAmountString = cnAmountString.Replace("億", "亿");
            cnAmountString = cnAmountString.Replace("千", "仟");
            cnAmountString = cnAmountString.Replace("百", "佰");
            cnAmountString = cnAmountString.Replace("十", "拾");
            cnAmountString = cnAmountString.Replace("元", "圆");
            return cnAmountString;

        }
         /// <summary>
        /// 将万亿的金额单位由"兆"改为"万"或者由"万"改为"兆"
        /// </summary>
        /// <param name="amountString">金额字符串</param>
        /// <param name="oldsString">要查找的单位字符，该字符将被替换</param>
        /// <param name="newString">新的字符单位，将去替换旧的字符单位</param>
        /// <returns></returns>
        public static string TrillionAmountUnit(string amountString,string oldsString,string newString)
        {
            string tempStr1=null ;
            string tempStr2 = null;
            string[] strArray = null;
            if (amountString.Contains("亿"))
            {
                strArray = amountString.Split('亿');
                tempStr1 = strArray[0];
                tempStr2 = strArray[1];
                if (tempStr1.Contains(oldsString ))
                {
                    tempStr1 = tempStr1.Replace(oldsString , newString);
                }
                return tempStr1+"亿" + tempStr2;
            }
            else
            {
                return amountString;
            }

        }

    }
}

namespace ZTSM.Enumerations
{
    /// <summary>
    /// 金额数字的枚举
    /// </summary>
    public enum AmountDigital
    {
        /// <summary>
        /// 人民币形式的中文金额数字
        /// </summary>
        RMB,
        /// <summary>
        /// 阿拉伯数字形式的金额数字
        /// </summary>
        ALB
    }

}

Code
namespace ZTSM.Factorys
{
    /// <summary>
    ///金额转换简单工厂
    /// </summary>
    public class AmountConversionFactory
    {
        /// <summary>
        /// 创建大写金额的类
        /// </summary>
        /// <returns></returns>
        public static List<ZTSM.Interfaces.IAmountConversion> CreateCapitalAmountClass()
        {
            List<ZTSM.Interfaces.IAmountConversion> list = new List<ZTSM.Interfaces.IAmountConversion>();
            list.Add(new ZTSM.Auxiliary.CnQianWanYi());
            list.Add(new ZTSM.Auxiliary.CnBaiWanYi());
            list.Add(new ZTSM.Auxiliary.CnShiWanYi());
            list.Add(new ZTSM.Auxiliary.CnWanYi());
            list.Add(new ZTSM.Auxiliary.CnQianYi());
            list.Add(new ZTSM.Auxiliary.CnBaiYi());
            list.Add(new ZTSM.Auxiliary.CnShiYi());
            list.Add(new ZTSM.Auxiliary.CnYi());
            list.Add(new ZTSM.Auxiliary.CnQianWan());
            list.Add(new ZTSM.Auxiliary.CnBaiWan());
            list.Add(new ZTSM.Auxiliary.CnShiWan());
            list.Add(new ZTSM.Auxiliary.CnWan());
            list.Add(new ZTSM.Auxiliary.CnQian());
            list.Add(new ZTSM.Auxiliary.CnBai());
            list.Add(new ZTSM.Auxiliary.CnShi());
            list.Add(new ZTSM.Auxiliary.CnYuan());
            list.Add(new ZTSM.Auxiliary.CnJiao());
            list.Add(new ZTSM.Auxiliary.CnFen());
            return list;
        }
        /// <summary>
        /// 创建小写金额的类
        /// </summary>
        /// <returns></returns>
        public static List<ZTSM.Interfaces.IAmountConversion> CreateLowercaseAmountClass()
        {
            List<ZTSM.Interfaces.IAmountConversion> list = new List<ZTSM.Interfaces.IAmountConversion>();
            list.Add(new ZTSM.Auxiliary.AlbQian());
            list.Add(new ZTSM.Auxiliary.AlbBai());
            list.Add(new ZTSM.Auxiliary.AlbShi());
            list.Add(new ZTSM.Auxiliary.AlbZhao());
            list.Add(new ZTSM.Auxiliary.AlbYi());
            list.Add(new ZTSM.Auxiliary.AlbWan());
            list.Add(new ZTSM.Auxiliary.AlbYuan());
            list.Add(new ZTSM.Auxiliary.AlbJiao());
            list.Add(new ZTSM.Auxiliary.AlbFen());
            return list;
        }

    }
}

Code
namespace ZTSM.Auxiliary
{
    /// <summary>
    ///转换金额类
    /// </summary>
    public class ConversionAmount
    {
        ZTSM.Entity.Amount a;
        /// <summary>
        /// 实例化转换金额类。
        /// </summary>
        /// <param name="amountString">金额字符串</param>
        public ConversionAmount(string amountString)
        {
            a = new ZTSM.Entity.Amount(amountString);
        }
        /// <summary>
        /// 转换到大写金额
        /// </summary>
        /// <returns>中文大写金额</returns>
        public string  ToCapitalAmount()
        {
            List<ZTSM.Interfaces.IAmountConversion> cs = ZTSM.Factorys.AmountConversionFactory.CreateCapitalAmountClass();
            foreach (ZTSM.Interfaces.IAmountConversion ia in cs)
            {
                ia.Interpret(a);
            }
            return ZTSM.ZTSMTools.Conversion.RemoveZeroAmountString( a.OutputAmount);
        }
        /// <summary>
        /// 转换到小写金额
        /// </summary>
        /// <returns>阿拉伯数字金额</returns>
        public string ToLowercaseAmount()
        {
            List<ZTSM.Interfaces.IAmountConversion> cs = ZTSM.Factorys.AmountConversionFactory.CreateLowercaseAmountClass();
            foreach (ZTSM.Interfaces.IAmountConversion ia in cs)
            {
                ia.Interpret(a);
            }
            if (string.IsNullOrEmpty(a.OutNumberAmount.ToString())||a.OutNumberAmount ==0)
            {
                return a.OutputAmount;
            }
            else
            {
                return a.OutNumberAmount.ToString();
            }
        }
   }

Code
<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
    <title>金额转换</title>
</head>
<body>
    <form id="form1" runat="server">
    <div>

        <asp:TextBox ID="TextBox1" runat="server" Width="504px" Height="22px"></asp:TextBox>

<br/><br/>

        <asp:Button ID="Button1" runat="server" Text="到大写金额" onclick="Button1_Click" />
        <asp:Button ID="Button2" runat="server" onclick="Button2_Click" Text="到小写金额" />

<br/><br/>
        <asp:Label ID="Label1" runat="server" Text=""></asp:Label>

    </div>
    </form>
</body>
</html>

Code
protected void Button2_Click(object sender, EventArgs e)
    {
        Label1.Text = new ZTSM.Auxiliary.ConversionAmount(TextBox1.Text).ToLowercaseAmount ();
    }

protected void Button1_Click(object sender, EventArgs e)
    {
        Label1.Text = new ZTSM.Auxiliary.ConversionAmount(TextBox1.Text).ToCapitalAmount ();

    }