金额大小写转换
一、接口
Codenamespace 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);
}
}
二、类
1、大写
Codenamespace 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";
}
}
}
2、小写
Codenamespace 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";
}
}
}
三、实体
Codenamespace 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;
}
}
}
}
四、其它
Codenamespace 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
}
}
五、工厂
Codenamespace 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;
}
}
}
六、逻辑
Codenamespace 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();
}
}
}
七、html
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>
后台代码
Codeprotected 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 ();
}
浙公网安备 33010602011771号