blocks|key|3340824|text|如果你使用：converting+numbers+in+to+words+C#中的代码，并且你需要它来处理十进制数，下面是如何做的：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3340825|public+string+DecimalToWords(decimal+number)
{
++++if+(number+==+0)
++++++++return+"zero";

++++if+(number+<+0)
++++++++return+"minus+"+%2B+DecimalToWords(Math.Abs(number));

++++string+words+=+"";

++++int+intPortion+=+(int)number;
++++decimal+fraction+=+(number+-+intPortion)*100;
++++int+decPortion+=+(int)fraction;

++++words+=+NumericToWords(intPortion);
++++if+(decPortion+>+0)
++++{
++++++++words+%2B=+"+and+";
++++++++words+%2B=+NumericToWords(decPortion);
++++}
++++return+words;
}|code-block|syntax|javascript|3340826|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/2729752/converting-numbers-in-to-words-c-sharp^0|6|X|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

if you use the code found in:
<a href="https://stackoverflow.com/questions/2729752/converting-numbers-in-to-words-c-sharp">converting numbers in to words C#</a>
and you need it for decimal numbers, here is how to do it:

<pre><code>public string DecimalToWords(decimal number)
{
 if (number == 0)
 return "zero";

 if (number &lt; 0)
 return "minus " + DecimalToWords(Math.Abs(number));

 string words = "";

 int intPortion = (int)number;
 decimal fraction = (number - intPortion)*100;
 int decPortion = (int)fraction;

 words = NumericToWords(intPortion);
 if (decPortion &gt; 0)
 {
 words += " and ";
 words += NumericToWords(decPortion);
 }
 return words;
}
</code></pre>

blocks|key|3340884|text|http://www.exchangecore.com/blog/convert-number-words-c-sharp-console-application/有一些C#脚本，可以处理非常大的数字和非常小的小数。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3340885|using+System;
using+System.Collections.Generic;
using+System.Text;

namespace+NumWords
{
++++class+Program
++++{
++++++++//+PROGRAM+HANDLES+NEGATIVE+AND+POSITIVE+DOUBLES


++++++++static+String+NumWordsWrapper(double+n)
++++++++{
++++++++++++string+words+=+"";
++++++++++++double+intPart;
++++++++++++double+decPart+=+0;
++++++++++++if+(n+==+0)
++++++++++++++++return+"zero";
++++++++++++try+{
++++++++++++++++string[]+splitter+=+n.ToString().Split('.');
++++++++++++++++intPart+=+double.Parse(splitter[0]);
++++++++++++++++decPart+=+double.Parse(splitter[1]);
++++++++++++}+catch+{
++++++++++++++++intPart+=+n;
++++++++++++}

++++++++++++words+=+NumWords(intPart);

++++++++++++if+(decPart+>+0)+{
++++++++++++++++if+(words+!=+"")
++++++++++++++++++++words+%2B=+"+and+";
++++++++++++++++int+counter+=+decPart.ToString().Length;
++++++++++++++++switch+(counter)+{
++++++++++++++++++++case+1:+words+%2B=+NumWords(decPart)+%2B+"+tenths";+break;
++++++++++++++++++++case+2:+words+%2B=+NumWords(decPart)+%2B+"+hundredths";+break;
++++++++++++++++++++case+3:+words+%2B=+NumWords(decPart)+%2B+"+thousandths";+break;
++++++++++++++++++++case+4:+words+%2B=+NumWords(decPart)+%2B+"+ten-thousandths";+break;
++++++++++++++++++++case+5:+words+%2B=+NumWords(decPart)+%2B+"+hundred-thousandths";+break;
++++++++++++++++++++case+6:+words+%2B=+NumWords(decPart)+%2B+"+millionths";+break;
++++++++++++++++++++case+7:+words+%2B=+NumWords(decPart)+%2B+"+ten-millionths";+break;
++++++++++++++++}
++++++++++++}
++++++++++++return+words;
++++++++}

++++++++static+String+NumWords(double+n)+//converts+double+to+words
++++++++{
++++++++++++string[]+numbersArr+=+new+string[]+{+"one",+"two",+"three",+"four",+"five",+"six",+"seven",+"eight",+"nine",+"ten",+"eleven",+"twelve",+"thirteen",+"fourteen",+"fifteen",+"sixteen",+"seventeen",+"eighteen",+"nineteen"+};
++++++++++++string[]+tensArr+=+new+string[]+{+"twenty",+"thirty",+"fourty",+"fifty",+"sixty",+"seventy",+"eighty",+"ninty"+};
++++++++++++string[]+suffixesArr+=+new+string[]+{+"thousand",+"million",+"billion",+"trillion",+"quadrillion",+"quintillion",+"sextillion",+"septillion",+"octillion",+"nonillion",+"decillion",+"undecillion",+"duodecillion",+"tredecillion",+"Quattuordecillion",+"Quindecillion",+"Sexdecillion",+"Septdecillion",+"Octodecillion",+"Novemdecillion",+"Vigintillion"+};
++++++++++++string+words+=+"";

++++++++++++bool+tens+=+false;

++++++++++++if+(n+<+0)+{
++++++++++++++++words+%2B=+"negative+";
++++++++++++++++n+*=+-1;
++++++++++++}

++++++++++++int+power+=+(suffixesArr.Length+%2B+1)+*+3;

++++++++++++while+(power+>+3)+{
++++++++++++++++double+pow+=+Math.Pow(10,+power);
++++++++++++++++if+(n+>=+pow)+{
++++++++++++++++++++if+(n+%25+pow+>+0)+{
++++++++++++++++++++++++words+%2B=+NumWords(Math.Floor(n+/+pow))+%2B+"+"+%2B+suffixesArr[(power+/+3)+-+1]+%2B+",+";
++++++++++++++++++++}+else+if+(n+%25+pow+==+0)+{
++++++++++++++++++++++++words+%2B=+NumWords(Math.Floor(n+/+pow))+%2B+"+"+%2B+suffixesArr[(power+/+3)+-+1];
++++++++++++++++++++}
++++++++++++++++++++n+%25=+pow;
++++++++++++++++}
++++++++++++++++power+-=+3;
++++++++++++}
++++++++++++if+(n+>=+1000)+{
++++++++++++++++if+(n+%25+1000+>+0)+words+%2B=+NumWords(Math.Floor(n+/+1000))+%2B+"+thousand,+";
++++++++++++++++else+words+%2B=+NumWords(Math.Floor(n+/+1000))+%2B+"+thousand";
++++++++++++++++n+%25=+1000;
++++++++++++}
++++++++++++if+(0+<=+n+&&+n+<=+999)+{
++++++++++++++++if+((int)n+/+100+>+0)+{
++++++++++++++++++++words+%2B=+NumWords(Math.Floor(n+/+100))+%2B+"+hundred";
++++++++++++++++++++n+%25=+100;
++++++++++++++++}
++++++++++++++++if+((int)n+/+10+>+1)+{
++++++++++++++++++++if+(words+!=+"")
++++++++++++++++++++++++words+%2B=+"+";
++++++++++++++++++++words+%2B=+tensArr[(int)n+/+10+-+2];
++++++++++++++++++++tens+=+true;
++++++++++++++++++++n+%25=+10;
++++++++++++++++}

++++++++++++++++if+(n+<+20+&&+n+>+0)+{
++++++++++++++++++++if+(words+!=+""+&&+tens+==+false)
++++++++++++++++++++++++words+%2B=+"+";
++++++++++++++++++++words+%2B=+(tens+?+"-"+%2B+numbersArr[(int)n+-+1]+:+numbersArr[(int)n+-+1]);
++++++++++++++++++++n+-=+Math.Floor(n);
++++++++++++++++}
++++++++++++}

++++++++++++return+words;

++++++++}
++++++++static+void+Main(string[]+args)
++++++++{
++++++++++++Console.Write("Enter+a+number+to+convert+to+words:+");
++++++++++++Double+n+=+Double.Parse(Console.ReadLine());

++++++++++++Console.WriteLine("{0}",+NumWordsWrapper(n));
++++++++}
++++}
}|code-block|syntax|javascript|3340886|编辑:从博客文章中带出代码|3340887|entityMap|0|LINK|mutability|MUTABLE|url|http://www.exchangecore.com/blog/convert-number-words-c-sharp-console-application/^0|0|2A|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|F|7|W|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|X|8|@]|9|@]|C|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]]]

<a href="http://www.exchangecore.com/blog/convert-number-words-c-sharp-console-application/" rel="nofollow">http://www.exchangecore.com/blog/convert-number-words-c-sharp-console-application/</a> has some C# script that looks to handle very large numbers and very small decimals.

<pre><code>using System;
using System.Collections.Generic;
using System.Text;

namespace NumWords
{
 class Program
 {
 // PROGRAM HANDLES NEGATIVE AND POSITIVE DOUBLES


 static String NumWordsWrapper(double n)
 {
 string words = "";
 double intPart;
 double decPart = 0;
 if (n == 0)
 return "zero";
 try {
 string[] splitter = n.ToString().Split('.');
 intPart = double.Parse(splitter[0]);
 decPart = double.Parse(splitter[1]);
 } catch {
 intPart = n;
 }

 words = NumWords(intPart);

 if (decPart &gt; 0) {
 if (words != "")
 words += " and ";
 int counter = decPart.ToString().Length;
 switch (counter) {
 case 1: words += NumWords(decPart) + " tenths"; break;
 case 2: words += NumWords(decPart) + " hundredths"; break;
 case 3: words += NumWords(decPart) + " thousandths"; break;
 case 4: words += NumWords(decPart) + " ten-thousandths"; break;
 case 5: words += NumWords(decPart) + " hundred-thousandths"; break;
 case 6: words += NumWords(decPart) + " millionths"; break;
 case 7: words += NumWords(decPart) + " ten-millionths"; break;
 }
 }
 return words;
 }

 static String NumWords(double n) //converts double to words
 {
 string[] numbersArr = new string[] { "one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen" };
 string[] tensArr = new string[] { "twenty", "thirty", "fourty", "fifty", "sixty", "seventy", "eighty", "ninty" };
 string[] suffixesArr = new string[] { "thousand", "million", "billion", "trillion", "quadrillion", "quintillion", "sextillion", "septillion", "octillion", "nonillion", "decillion", "undecillion", "duodecillion", "tredecillion", "Quattuordecillion", "Quindecillion", "Sexdecillion", "Septdecillion", "Octodecillion", "Novemdecillion", "Vigintillion" };
 string words = "";

 bool tens = false;

 if (n &lt; 0) {
 words += "negative ";
 n *= -1;
 }

 int power = (suffixesArr.Length + 1) * 3;

 while (power &gt; 3) {
 double pow = Math.Pow(10, power);
 if (n &gt;= pow) {
 if (n % pow &gt; 0) {
 words += NumWords(Math.Floor(n / pow)) + " " + suffixesArr[(power / 3) - 1] + ", ";
 } else if (n % pow == 0) {
 words += NumWords(Math.Floor(n / pow)) + " " + suffixesArr[(power / 3) - 1];
 }
 n %= pow;
 }
 power -= 3;
 }
 if (n &gt;= 1000) {
 if (n % 1000 &gt; 0) words += NumWords(Math.Floor(n / 1000)) + " thousand, ";
 else words += NumWords(Math.Floor(n / 1000)) + " thousand";
 n %= 1000;
 }
 if (0 &lt;= n &amp;&amp; n &lt;= 999) {
 if ((int)n / 100 &gt; 0) {
 words += NumWords(Math.Floor(n / 100)) + " hundred";
 n %= 100;
 }
 if ((int)n / 10 &gt; 1) {
 if (words != "")
 words += " ";
 words += tensArr[(int)n / 10 - 2];
 tens = true;
 n %= 10;
 }

 if (n &lt; 20 &amp;&amp; n &gt; 0) {
 if (words != "" &amp;&amp; tens == false)
 words += " ";
 words += (tens ? "-" + numbersArr[(int)n - 1] : numbersArr[(int)n - 1]);
 n -= Math.Floor(n);
 }
 }

 return words;

 }
 static void Main(string[] args)
 {
 Console.Write("Enter a number to convert to words: ");
 Double n = Double.Parse(Console.ReadLine());

 Console.WriteLine("{0}", NumWordsWrapper(n));
 }
 }
}
</code></pre>

EDIT: brought code over from blog post

blocks|key|352753|text|Imports+System.Text

Public+Class+NumberWriter

++++Public+Shared+Function+Parse(ByVal+Number+As+String)+As+String
++++++++If+Not+AreNumbers(Number)+Then+Return+""
++++++++Dim+TempQueue+As+New+Queue(Of+String)
++++++++For+Each+ItemA+As+Char+In+Number.Replace(",",+"").Reverse
++++++++++++TempQueue.Enqueue(ItemA)
++++++++Next
++++++++Dim+Blocks+As+New+List(Of+String)
++++++++Dim+BlockEmpty+As+New+List(Of+Boolean)
++++++++Do
++++++++++++Dim+TempBlock+As+New+StringBuilder(3)
++++++++++++TempBlock.Append(TempQueue.Dequeue)
++++++++++++If+TempQueue.Count+>+0+Then
++++++++++++++++TempBlock.Append(TempQueue.Dequeue)
++++++++++++++++If+TempQueue.Count+>+0+Then
++++++++++++++++++++TempBlock.Append(TempQueue.Dequeue)
++++++++++++++++End+If
++++++++++++End+If
++++++++++++Blocks.Add(StrReverse(TempBlock.ToString))
++++++++++++BlockEmpty.Add(TempBlock.ToString+=+"000")
++++++++++++If+TempQueue.Count+<+1+Then+Exit+Do
++++++++Loop
++++++++Dim+ResultStack+As+New+Stack(Of+String)
++++++++For+int1+As+Integer+=+0+To+Blocks.Count+-+1
++++++++++++ResultStack.Push(ReadBlock(Blocks(int1))+&+If(Not+int1+=+0,+If(Not+BlockEmpty(int1),+"+"+&+CapitalizeWord(GetPlaceValueSet(int1))+&+If(BlockEmpty(int1+-+1),+"",+",+"),+""),+""))
++++++++Next
++++++++Dim+Result1+As+String+=+""
++++++++Do+Until+ResultStack.Count+<+1
++++++++++++Result1+&=+ResultStack.Pop
++++++++Loop
++++++++Return+RemoveGrammarErrors(Result1)
++++End+Function

++++Private+Shared+Function+RemoveGrammarErrors(ByVal+Str+As+String)+As+String
++++++++Dim+tstr+As+String+=+Str
++++++++tstr.Replace("++",+"+")
++++++++tstr.Replace("+,+",+",+")
++++++++Return+tstr
++++End+Function

++++Private+Shared+Function+AreNumbers(ByVal+Str1+As+String)+As+Boolean
++++++++Dim+Numbers()+As+String+=+{"0",+"1",+"2",+"3",+"4",+"5",+"6",+"7",+"8",+"9",+","}
++++++++For+Each+ItemA+As+Char+In+Str1
++++++++++++Dim+IsN+As+Boolean+=+False
++++++++++++For+Each+ItemB+As+String+In+Numbers
++++++++++++++++If+ItemA+=+ItemB+Then+IsN+=+True
++++++++++++Next
++++++++++++If+Not+IsN+Then
++++++++++++++++Return+False
++++++++++++End+If
++++++++Next
++++++++Return+True
++++End+Function

++++Private+Shared+Function+ReadBlock(ByVal+Block+As+String)
++++++++Select+Case+Block.Length
++++++++++++Case+1
++++++++++++++++Return+ReadSingleDigit(Block)
++++++++++++Case+2
++++++++++++++++Return+ReadTwoDigits(Block)
++++++++++++Case+3
++++++++++++++++Return+ReadThreeDigits(Block)
++++++++++++Case+Else
++++++++++++++++Throw+New+Exception
++++++++End+Select
++++End+Function

++++Private+Shared+Function+ReadThreeDigits(ByVal+Digits+As+String)
++++++++If+Digits.Length+>+3+Then+Throw+New+ArgumentException("There+are+too+many+digits.")
++++++++Dim+Result+As+String+=+""
++++++++If+Not+Digits(0)+=+"0"+Then
++++++++++++Result+&=+ReadSingleDigit(Digits(0))+&+"+Hundred+"
++++++++End+If
++++++++Result+&=+ReadTwoDigits(Digits.Substring(1))
++++++++Return+Result
++++End+Function

++++Private+Shared+Function+ReadTwoDigits(ByVal+Digits+As+String)
++++++++If+Digits.Length+>+2+Then+Throw+New+ArgumentException("There+are+too+many+digits.")
++++++++Select+Case+Digits(0)
++++++++++++Case+"0"
++++++++++++++++Return+ReadSingleDigit(Digits(1))
++++++++++++Case+"1"
++++++++++++++++Return+ReadTeenNumber(Digits)
++++++++++++Case+Else
++++++++++++++++Return+ReadFirstInNumberPair(Digits(0))+&+If(Digits(1)+=+"0",+"",+"-"+&+ReadSingleDigit(Digits(1)))
++++++++End+Select
++++End+Function

++++Private+Shared+Function+ReadSingleDigit(ByVal+Digit+As+String)+As+String
++++++++If+Not+Digit.Length+=+1+Then+Throw+New+ArgumentException("There+must+be+only+one+digit+and+it+must+be+more+than+zero.")
++++++++Select+Case+Digit
++++++++++++Case+"0"
++++++++++++++++Return+""
++++++++++++Case+"1"
++++++++++++++++Return+"One"
++++++++++++Case+"2"
++++++++++++++++Return+"Two"
++++++++++++Case+"3"
++++++++++++++++Return+"Three"
++++++++++++Case+"4"
++++++++++++++++Return+"Four"
++++++++++++Case+"5"
++++++++++++++++Return+"Five"
++++++++++++Case+"6"
++++++++++++++++Return+"Six"
++++++++++++Case+"7"
++++++++++++++++Return+"Seven"
++++++++++++Case+"8"
++++++++++++++++Return+"Eight"
++++++++++++Case+"9"
++++++++++++++++Return+"Nine"
++++++++++++Case+Else
++++++++++++++++Throw+New+Exception()
++++++++End+Select
++++End+Function

++++Private+Shared+Function+ReadTeenNumber(ByVal+Num+As+String)+As+String
++++++++Select+Case+Num
++++++++++++Case+"11"
++++++++++++++++Return+"Eleven"
++++++++++++Case+"12"
++++++++++++++++Return+"Twelve"
++++++++++++Case+"13"
++++++++++++++++Return+"Thirteen"
++++++++++++Case+"14"
++++++++++++++++Return+"Fourteen"
++++++++++++Case+"15"
++++++++++++++++Return+"Fifteen"
++++++++++++Case+"16"
++++++++++++++++Return+"Sixteen"
++++++++++++Case+"17"
++++++++++++++++Return+"Seventeen"
++++++++++++Case+"18"
++++++++++++++++Return+"Eighteen"
++++++++++++Case+"19"
++++++++++++++++Return+"Nineteen"
++++++++++++Case+Else
++++++++++++++++Throw+New+Exception()
++++++++End+Select
++++End+Function

++++Private+Shared+Function+ReadFirstInNumberPair(ByVal+Num+As+String)+As+String
++++++++If+Not+(Num+>+1+OrElse+Num+<+10)+Then+Throw+New+ArgumentException("Number+must+be+more+than+1+and+less+than+10")
++++++++Select+Case+Num
++++++++++++Case+"2"
++++++++++++++++Return+"Twenty"
++++++++++++Case+"3"
++++++++++++++++Return+"Thirty"
++++++++++++Case+"4"
++++++++++++++++Return+"Fourty"
++++++++++++Case+"5"
++++++++++++++++Return+"Fifty"
++++++++++++Case+"6"
++++++++++++++++Return+"Sixty"
++++++++++++Case+"7"
++++++++++++++++Return+"Seventy"
++++++++++++Case+"8"
++++++++++++++++Return+"Eighty"
++++++++++++Case+"9"
++++++++++++++++Return+"Ninety"
++++++++++++Case+Else
++++++++++++++++Throw+New+Exception()
++++++++End+Select
++++End+Function

++++Private+Shared+Function+CapitalizeWord(ByVal+Word+As+String)+As+String
++++++++Return+Word.Substring(0,+1).ToUpper+&+Word.Substring(1)
++++End+Function

++++Private+Shared+Function+GetPlaceValueSet(ByVal+Num+As+Byte)+As+String
++++++++Select+Case+Num
++++++++++++Case+0
++++++++++++++++Return+""+'Hundreds
++++++++++++Case+1
++++++++++++++++Return+"Thousand"
++++++++++++Case+2
++++++++++++++++Return+"Million"
++++++++++++Case+3
++++++++++++++++Return+"Billion"
++++++++++++Case+4
++++++++++++++++Return+"Trillion"
++++++++++++Case+5
++++++++++++++++Return+"Quadrillion"
++++++++++++Case+6
++++++++++++++++Return+"Quintillion"
++++++++++++Case+7
++++++++++++++++Return+"Sextillion"
++++++++++++Case+8
++++++++++++++++Return+"Septillion"
++++++++++++Case+9
++++++++++++++++Return+"Octillion"
++++++++++++Case+10
++++++++++++++++Return+"Nonillion"
++++++++++++Case+11
++++++++++++++++Return+"octillion"
++++++++++++Case+12
++++++++++++++++Return+"nonillion"
++++++++++++Case+13
++++++++++++++++Return+"decillion"
++++++++++++Case+14
++++++++++++++++Return+"undecillion"
++++++++++++Case+15
++++++++++++++++Return+"dodecillion,"
++++++++++++Case+16
++++++++++++++++Return+"tredecillion"
++++++++++++Case+17
++++++++++++++++Return+"quattuordecillion"
++++++++++++Case+18
++++++++++++++++Return+"quindecillion"
++++++++++++Case+19
++++++++++++++++Return+"sexdecillion"
++++++++++++Case+20
++++++++++++++++Return+"septendecillion"
++++++++++++Case+21
++++++++++++++++Return+"octodecillion"
++++++++++++Case+22
++++++++++++++++Return+"novemdecillion"
++++++++++++Case+23
++++++++++++++++Return+"vigintillion"
++++++++++++Case+24
++++++++++++++++Return+"unvigintillion"
++++++++++++Case+25
++++++++++++++++Return+"dovigintillion"
++++++++++++Case+26
++++++++++++++++Return+"trevigintillion"
++++++++++++Case+27
++++++++++++++++Return+"quattuorvigintillion"
++++++++++++Case+28
++++++++++++++++Return+"quinvigintillion"
++++++++++++Case+29
++++++++++++++++Return+"sexvigintillion"
++++++++++++Case+30
++++++++++++++++Return+"septenvigintillion"
++++++++++++Case+31
++++++++++++++++Return+"octovigintillion"
++++++++++++Case+32
++++++++++++++++Return+"novemvigintillion"
++++++++++++Case+33
++++++++++++++++Return+"trigintillion"
++++++++++++Case+34
++++++++++++++++Return+"untrigintillion"
++++++++++++Case+35
++++++++++++++++Return+"dotrigintillion"
++++++++++++Case+36
++++++++++++++++Return+"tretrigintillion"
++++++++++++Case+37
++++++++++++++++Return+"quattuortrigintillion"
++++++++++++Case+38
++++++++++++++++Return+"quintrigintillion"
++++++++++++Case+39
++++++++++++++++Return+"sextrigintillion"
++++++++++++Case+40
++++++++++++++++Return+"septentrigintillion"
++++++++++++Case+41
++++++++++++++++Return+"octotrigintillion"
++++++++++++Case+Else
++++++++++++++++Throw+New+Exception
++++++++End+Select
++++End+Function
End+Class|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|352754|对不起，它是在VB.NET中，但它完全可以工作。这是一种方式。数字转换为文字。我相信可以处理最多123个字符的数字。|unstyled|352755|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre class="lang-vb prettyprint-override"><code>Imports System.Text

Public Class NumberWriter

 Public Shared Function Parse(ByVal Number As String) As String
 If Not AreNumbers(Number) Then Return ""
 Dim TempQueue As New Queue(Of String)
 For Each ItemA As Char In Number.Replace(",", "").Reverse
 TempQueue.Enqueue(ItemA)
 Next
 Dim Blocks As New List(Of String)
 Dim BlockEmpty As New List(Of Boolean)
 Do
 Dim TempBlock As New StringBuilder(3)
 TempBlock.Append(TempQueue.Dequeue)
 If TempQueue.Count &gt; 0 Then
 TempBlock.Append(TempQueue.Dequeue)
 If TempQueue.Count &gt; 0 Then
 TempBlock.Append(TempQueue.Dequeue)
 End If
 End If
 Blocks.Add(StrReverse(TempBlock.ToString))
 BlockEmpty.Add(TempBlock.ToString = "000")
 If TempQueue.Count &lt; 1 Then Exit Do
 Loop
 Dim ResultStack As New Stack(Of String)
 For int1 As Integer = 0 To Blocks.Count - 1
 ResultStack.Push(ReadBlock(Blocks(int1)) &amp; If(Not int1 = 0, If(Not BlockEmpty(int1), " " &amp; CapitalizeWord(GetPlaceValueSet(int1)) &amp; If(BlockEmpty(int1 - 1), "", ", "), ""), ""))
 Next
 Dim Result1 As String = ""
 Do Until ResultStack.Count &lt; 1
 Result1 &amp;= ResultStack.Pop
 Loop
 Return RemoveGrammarErrors(Result1)
 End Function

 Private Shared Function RemoveGrammarErrors(ByVal Str As String) As String
 Dim tstr As String = Str
 tstr.Replace(" ", " ")
 tstr.Replace(" , ", ", ")
 Return tstr
 End Function

 Private Shared Function AreNumbers(ByVal Str1 As String) As Boolean
 Dim Numbers() As String = {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9", ","}
 For Each ItemA As Char In Str1
 Dim IsN As Boolean = False
 For Each ItemB As String In Numbers
 If ItemA = ItemB Then IsN = True
 Next
 If Not IsN Then
 Return False
 End If
 Next
 Return True
 End Function

 Private Shared Function ReadBlock(ByVal Block As String)
 Select Case Block.Length
 Case 1
 Return ReadSingleDigit(Block)
 Case 2
 Return ReadTwoDigits(Block)
 Case 3
 Return ReadThreeDigits(Block)
 Case Else
 Throw New Exception
 End Select
 End Function

 Private Shared Function ReadThreeDigits(ByVal Digits As String)
 If Digits.Length &gt; 3 Then Throw New ArgumentException("There are too many digits.")
 Dim Result As String = ""
 If Not Digits(0) = "0" Then
 Result &amp;= ReadSingleDigit(Digits(0)) &amp; " Hundred "
 End If
 Result &amp;= ReadTwoDigits(Digits.Substring(1))
 Return Result
 End Function

 Private Shared Function ReadTwoDigits(ByVal Digits As String)
 If Digits.Length &gt; 2 Then Throw New ArgumentException("There are too many digits.")
 Select Case Digits(0)
 Case "0"
 Return ReadSingleDigit(Digits(1))
 Case "1"
 Return ReadTeenNumber(Digits)
 Case Else
 Return ReadFirstInNumberPair(Digits(0)) &amp; If(Digits(1) = "0", "", "-" &amp; ReadSingleDigit(Digits(1)))
 End Select
 End Function

 Private Shared Function ReadSingleDigit(ByVal Digit As String) As String
 If Not Digit.Length = 1 Then Throw New ArgumentException("There must be only one digit and it must be more than zero.")
 Select Case Digit
 Case "0"
 Return ""
 Case "1"
 Return "One"
 Case "2"
 Return "Two"
 Case "3"
 Return "Three"
 Case "4"
 Return "Four"
 Case "5"
 Return "Five"
 Case "6"
 Return "Six"
 Case "7"
 Return "Seven"
 Case "8"
 Return "Eight"
 Case "9"
 Return "Nine"
 Case Else
 Throw New Exception()
 End Select
 End Function

 Private Shared Function ReadTeenNumber(ByVal Num As String) As String
 Select Case Num
 Case "11"
 Return "Eleven"
 Case "12"
 Return "Twelve"
 Case "13"
 Return "Thirteen"
 Case "14"
 Return "Fourteen"
 Case "15"
 Return "Fifteen"
 Case "16"
 Return "Sixteen"
 Case "17"
 Return "Seventeen"
 Case "18"
 Return "Eighteen"
 Case "19"
 Return "Nineteen"
 Case Else
 Throw New Exception()
 End Select
 End Function

 Private Shared Function ReadFirstInNumberPair(ByVal Num As String) As String
 If Not (Num &gt; 1 OrElse Num &lt; 10) Then Throw New ArgumentException("Number must be more than 1 and less than 10")
 Select Case Num
 Case "2"
 Return "Twenty"
 Case "3"
 Return "Thirty"
 Case "4"
 Return "Fourty"
 Case "5"
 Return "Fifty"
 Case "6"
 Return "Sixty"
 Case "7"
 Return "Seventy"
 Case "8"
 Return "Eighty"
 Case "9"
 Return "Ninety"
 Case Else
 Throw New Exception()
 End Select
 End Function

 Private Shared Function CapitalizeWord(ByVal Word As String) As String
 Return Word.Substring(0, 1).ToUpper &amp; Word.Substring(1)
 End Function

 Private Shared Function GetPlaceValueSet(ByVal Num As Byte) As String
 Select Case Num
 Case 0
 Return "" 'Hundreds
 Case 1
 Return "Thousand"
 Case 2
 Return "Million"
 Case 3
 Return "Billion"
 Case 4
 Return "Trillion"
 Case 5
 Return "Quadrillion"
 Case 6
 Return "Quintillion"
 Case 7
 Return "Sextillion"
 Case 8
 Return "Septillion"
 Case 9
 Return "Octillion"
 Case 10
 Return "Nonillion"
 Case 11
 Return "octillion"
 Case 12
 Return "nonillion"
 Case 13
 Return "decillion"
 Case 14
 Return "undecillion"
 Case 15
 Return "dodecillion,"
 Case 16
 Return "tredecillion"
 Case 17
 Return "quattuordecillion"
 Case 18
 Return "quindecillion"
 Case 19
 Return "sexdecillion"
 Case 20
 Return "septendecillion"
 Case 21
 Return "octodecillion"
 Case 22
 Return "novemdecillion"
 Case 23
 Return "vigintillion"
 Case 24
 Return "unvigintillion"
 Case 25
 Return "dovigintillion"
 Case 26
 Return "trevigintillion"
 Case 27
 Return "quattuorvigintillion"
 Case 28
 Return "quinvigintillion"
 Case 29
 Return "sexvigintillion"
 Case 30
 Return "septenvigintillion"
 Case 31
 Return "octovigintillion"
 Case 32
 Return "novemvigintillion"
 Case 33
 Return "trigintillion"
 Case 34
 Return "untrigintillion"
 Case 35
 Return "dotrigintillion"
 Case 36
 Return "tretrigintillion"
 Case 37
 Return "quattuortrigintillion"
 Case 38
 Return "quintrigintillion"
 Case 39
 Return "sextrigintillion"
 Case 40
 Return "septentrigintillion"
 Case 41
 Return "octotrigintillion"
 Case Else
 Throw New Exception
 End Select
 End Function
End Class
</code></pre>

Sorry it's in VB.NET, but it works completely. It is one way. Number to Verbal. Handles numbers up to 123 characters long I believe.

blocks|key|3128169|text|这是我的解决方案，希望能对你有所帮助|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3128170|namespace+ConsoleApplication3
{

++++class+Program
++++{


++++++++static+void+Main(string[]+args)
++++++++{

++++++++++++string+s+=+Console.ReadLine();
++++++++++++ConvertMyword(int.Parse(s));

++++++++++++Console.Read();

++++++++}

++++++++static+void+ConvertMyword(int+number)
++++++++{
++++++++++++int+flag+=+0;
++++++++++++int+lflag+=+0;
++++++++++++string+words+=+String.Empty;
++++++++++++string[]+places+=+{+"ones",+"ten",+"hundred",+"thousand",+"ten+thousand",+"lacs","tenlacs","crore","tencrore"+};
++++++++++++string+rawnumber+=+number.ToString();
++++++++++++char[]+a+=+rawnumber.ToCharArray();
++++++++++++Array.Reverse(a);
++++++++++++for+(int+i+=+a.Length+-+1;+i+>=+0;+i--)
++++++++++++{
++++++++++++++++if+(i+%25+2+==+0+&&+i+>+2)
++++++++++++++++{
++++++++++++++++++++if+(int.Parse(a[i].ToString())+>+1)
++++++++++++++++++++{
++++++++++++++++++++++++if+(int.Parse(a[i+-+1].ToString())+==+0)
++++++++++++++++++++++++{
++++++++++++++++++++++++++++words+=+words+%2B+getNumberStringty(int.Parse(a[i].ToString()))+%2B+"+"+%2B+places[i+-+1]+%2B+"+";
++++++++++++++++++++++++}
++++++++++++++++++++++++else
++++++++++++++++++++++++{
++++++++++++++++++++++++++++words+=+words+%2B+getNumberStringty(int.Parse(a[i].ToString()))+%2B+"+";
++++++++++++++++++++++++}
++++++++++++++++++++}
++++++++++++++++++++else+if+(int.Parse(a[i].ToString())+==+1)
++++++++++++++++++++{
++++++++++++++++++++++++if+(int.Parse(a[i+-+1].ToString())==+0)
++++++++++++++++++++++++{
++++++++++++++++++++++++++++words+=+words+%2B"Ten"+%2B+"+";
++++++++++++++++++++++++}
++++++++++++++++++++++++else
++++++++++++++++++++++++{
++++++++++++++++++++++++++++words+=+words+%2B+getNumberStringteen(int.Parse(a[i+-+1].ToString()))+%2B+"+";
++++++++++++++++++++++++}
++++++++++++++++++++++++flag+=+1;
++++++++++++++++++++}
++++++++++++++++}
++++++++++++++++else
++++++++++++++++{
++++++++++++++++++++if+(i+==+1+%7C%7C+i+==+0)
++++++++++++++++++++{
++++++++++++++++++++++++if+(int.Parse(a[i].ToString())+>+1)
++++++++++++++++++++++++{
++++++++++++++++++++++++++++words+=+words+%2B+getNumberStringty(int.Parse(a[i].ToString()))+%2B+"+"+%2B+getNumberString(int.Parse(a[0].ToString()))+%2B+"+";
++++++++++++++++++++++++++++break;
++++++++++++++++++++++++}
++++++++++++++++++++++++else+if+(int.Parse(a[i].ToString())+==+1)
++++++++++++++++++++++++{
++++++++++++++++++++++++++++if+(int.Parse(a[i+-+1].ToString())+==+0)
++++++++++++++++++++++++++++{
++++++++++++++++++++++++++++++++words+=+words+%2B+"Ten"+%2B+"+";
++++++++++++++++++++++++++++}
++++++++++++++++++++++++++++else
++++++++++++++++++++++++++++{
++++++++++++++++++++++++++++++++words+=+words+%2B+getNumberStringteen(int.Parse(a[i+-+1].ToString()))+%2B+"+";
++++++++++++++++++++++++++++}

++++++++++++++++++++++++++++break;
++++++++++++++++++++++++}
++++++++++++++++++++++++else+if+(int.Parse(a[i+-+1].ToString())+!=+0)
++++++++++++++++++++++++{
++++++++++++++++++++++++++++words+=+words+%2B+getNumberString(int.Parse(a[i+-+1].ToString()))+%2B+"+";
++++++++++++++++++++++++++++break;
++++++++++++++++++++++++}
++++++++++++++++++++++++else
++++++++++++++++++++++++{
++++++++++++++++++++++++++++break;
++++++++++++++++++++++++}
++++++++++++++++++++}
++++++++++++++++++++else
++++++++++++++++++++{
++++++++++++++++++++++++if+(flag+==+0)
++++++++++++++++++++++++{
++++++++++++++++++++++++++++for(int+l=i;l>=0;l--)
++++++++++++++++++++++++++++{
++++++++++++++++++++++++++++++++if+(int.Parse(a[l].ToString())!=0)
++++++++++++++++++++++++++++++++{
++++++++++++++++++++++++++++++++++++lflag+=+1;
++++++++++++++++++++++++++++++++}
++++++++++++++++++++++++++++}
++++++++++++++++++++++++++++if+(lflag+==+1+&&+int.Parse(a[i].ToString())!=0)
++++++++++++++++++++++++++++{

++++++++++++++++++++++++++++++++++++words+=+words+%2B+getNumberString(int.Parse(a[i].ToString()))+%2B+"+"+%2B+places[i]+%2B+"+";
++++++++++++++++++++++++++++++++++++lflag+=+0;


++++++++++++++++++++++++++++}
++++++++++++++++++++++++++++else+if(lflag+==+0)
++++++++++++++++++++++++++++{
+++++++++++++++++++++++++++++++//+words+=+words+%2B+getNumberString(int.Parse(a[i].ToString()))+%2B+"+"+%2B+places[i]+%2B+"+";
++++++++++++++++++++++++++++++++lflag+=+0;
++++++++++++++++++++++++++++++++break;
++++++++++++++++++++++++++++}

++++++++++++++++++++++++}
++++++++++++++++++++++++else
++++++++++++++++++++++++{
++++++++++++++++++++++++++++words+=+words+%2B+"+"+%2B+places[i]+%2B+"+";
++++++++++++++++++++++++++++flag+=+0;
++++++++++++++++++++++++}

++++++++++++++++++++}
++++++++++++++++}
++++++++++++}
++++++++++++Console.WriteLine(words);
++++++++}
++++++++static+string+getNumberString(int+num)
++++++++{
++++++++++++string+Word+=+String.Empty;
++++++++++++switch+(num)
++++++++++++{
++++++++++++++++case+1:
++++++++++++++++++++Word+=+"one";
++++++++++++++++++++break;
++++++++++++++++case+2:
++++++++++++++++++++Word+=+"two";
++++++++++++++++++++break;

++++++++++++++++case+3:
++++++++++++++++++++Word+=+"three";
++++++++++++++++++++break;

++++++++++++++++case+4:
++++++++++++++++++++Word+=+"four";
++++++++++++++++++++break;

++++++++++++++++case+5:
++++++++++++++++++++Word+=+"five";
++++++++++++++++++++break;

++++++++++++++++case+6:
++++++++++++++++++++Word+=+"six";
++++++++++++++++++++break;
++++++++++++++++case+7:
++++++++++++++++++++Word+=+"seven";
++++++++++++++++++++break;

++++++++++++++++case+8:
++++++++++++++++++++Word+=+"eight";
++++++++++++++++++++break;

++++++++++++++++case+9:
++++++++++++++++++++Word+=+"nine";
++++++++++++++++++++break;


++++++++++++}
++++++++++++return+Word;
++++++++}
++++++++static+string+getNumberStringty(int+num)
++++++++{
++++++++++++string+Word+=+String.Empty;
++++++++++++switch+(num)
++++++++++++{

++++++++++++++++case+2:
++++++++++++++++++++Word+=+"twenty";
++++++++++++++++++++break;

++++++++++++++++case+3:
++++++++++++++++++++Word+=+"thirty";
++++++++++++++++++++break;

++++++++++++++++case+4:
++++++++++++++++++++Word+=+"fourty";
++++++++++++++++++++break;

++++++++++++++++case+5:
++++++++++++++++++++Word+=+"fifty";
++++++++++++++++++++break;

++++++++++++++++case+6:
++++++++++++++++++++Word+=+"sixty";
++++++++++++++++++++break;
++++++++++++++++case+7:
++++++++++++++++++++Word+=+"seventy";
++++++++++++++++++++break;

++++++++++++++++case+8:
++++++++++++++++++++Word+=+"eighty";
++++++++++++++++++++break;

++++++++++++++++case+9:
++++++++++++++++++++Word+=+"ninty";
++++++++++++++++++++break;


++++++++++++}
++++++++++++return+Word;
++++++++}
++++++++static+string+getNumberStringteen(int+num)
++++++++{
++++++++++++string+Word+=+String.Empty;
++++++++++++switch+(num)
++++++++++++{
++++++++++++++++++++case+1:
++++++++++++++++++++Word+=+"eleven";
++++++++++++++++++++break;
++++++++++++++++case+2:
++++++++++++++++++++Word+=+"tewlve";
++++++++++++++++++++break;

++++++++++++++++case+3:
++++++++++++++++++++Word+=+"thirteen";
++++++++++++++++++++break;

++++++++++++++++case+4:
++++++++++++++++++++Word+=+"fourteen";
++++++++++++++++++++break;

++++++++++++++++case+5:
++++++++++++++++++++Word+=+"fifteen";
++++++++++++++++++++break;

++++++++++++++++case+6:
++++++++++++++++++++Word+=+"sixteen";
++++++++++++++++++++break;
++++++++++++++++case+7:
++++++++++++++++++++Word+=+"seventeen";
++++++++++++++++++++break;

++++++++++++++++case+8:
++++++++++++++++++++Word+=+"eighteen";
++++++++++++++++++++break;

++++++++++++++++case+9:
++++++++++++++++++++Word+=+"ninteen";
++++++++++++++++++++break;


++++++++++++}
++++++++++++return+Word;
++++++++}
++++}

}|code-block|syntax|javascript|3128171|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here is my solution hope it will help you 

<pre><code>namespace ConsoleApplication3
{

 class Program
 {


 static void Main(string[] args)
 {

 string s = Console.ReadLine();
 ConvertMyword(int.Parse(s));

 Console.Read();

 }

 static void ConvertMyword(int number)
 {
 int flag = 0;
 int lflag = 0;
 string words = String.Empty;
 string[] places = { "ones", "ten", "hundred", "thousand", "ten thousand", "lacs","tenlacs","crore","tencrore" };
 string rawnumber = number.ToString();
 char[] a = rawnumber.ToCharArray();
 Array.Reverse(a);
 for (int i = a.Length - 1; i &gt;= 0; i--)
 {
 if (i % 2 == 0 &amp;&amp; i &gt; 2)
 {
 if (int.Parse(a[i].ToString()) &gt; 1)
 {
 if (int.Parse(a[i - 1].ToString()) == 0)
 {
 words = words + getNumberStringty(int.Parse(a[i].ToString())) + " " + places[i - 1] + " ";
 }
 else
 {
 words = words + getNumberStringty(int.Parse(a[i].ToString())) + " ";
 }
 }
 else if (int.Parse(a[i].ToString()) == 1)
 {
 if (int.Parse(a[i - 1].ToString())== 0)
 {
 words = words +"Ten" + " ";
 }
 else
 {
 words = words + getNumberStringteen(int.Parse(a[i - 1].ToString())) + " ";
 }
 flag = 1;
 }
 }
 else
 {
 if (i == 1 || i == 0)
 {
 if (int.Parse(a[i].ToString()) &gt; 1)
 {
 words = words + getNumberStringty(int.Parse(a[i].ToString())) + " " + getNumberString(int.Parse(a[0].ToString())) + " ";
 break;
 }
 else if (int.Parse(a[i].ToString()) == 1)
 {
 if (int.Parse(a[i - 1].ToString()) == 0)
 {
 words = words + "Ten" + " ";
 }
 else
 {
 words = words + getNumberStringteen(int.Parse(a[i - 1].ToString())) + " ";
 }

 break;
 }
 else if (int.Parse(a[i - 1].ToString()) != 0)
 {
 words = words + getNumberString(int.Parse(a[i - 1].ToString())) + " ";
 break;
 }
 else
 {
 break;
 }
 }
 else
 {
 if (flag == 0)
 {
 for(int l=i;l&gt;=0;l--)
 {
 if (int.Parse(a[l].ToString())!=0)
 {
 lflag = 1;
 }
 }
 if (lflag == 1 &amp;&amp; int.Parse(a[i].ToString())!=0)
 {

 words = words + getNumberString(int.Parse(a[i].ToString())) + " " + places[i] + " ";
 lflag = 0;


 }
 else if(lflag == 0)
 {
 // words = words + getNumberString(int.Parse(a[i].ToString())) + " " + places[i] + " ";
 lflag = 0;
 break;
 }

 }
 else
 {
 words = words + " " + places[i] + " ";
 flag = 0;
 }

 }
 }
 }
 Console.WriteLine(words);
 }
 static string getNumberString(int num)
 {
 string Word = String.Empty;
 switch (num)
 {
 case 1:
 Word = "one";
 break;
 case 2:
 Word = "two";
 break;

 case 3:
 Word = "three";
 break;

 case 4:
 Word = "four";
 break;

 case 5:
 Word = "five";
 break;

 case 6:
 Word = "six";
 break;
 case 7:
 Word = "seven";
 break;

 case 8:
 Word = "eight";
 break;

 case 9:
 Word = "nine";
 break;


 }
 return Word;
 }
 static string getNumberStringty(int num)
 {
 string Word = String.Empty;
 switch (num)
 {

 case 2:
 Word = "twenty";
 break;

 case 3:
 Word = "thirty";
 break;

 case 4:
 Word = "fourty";
 break;

 case 5:
 Word = "fifty";
 break;

 case 6:
 Word = "sixty";
 break;
 case 7:
 Word = "seventy";
 break;

 case 8:
 Word = "eighty";
 break;

 case 9:
 Word = "ninty";
 break;


 }
 return Word;
 }
 static string getNumberStringteen(int num)
 {
 string Word = String.Empty;
 switch (num)
 {
 case 1:
 Word = "eleven";
 break;
 case 2:
 Word = "tewlve";
 break;

 case 3:
 Word = "thirteen";
 break;

 case 4:
 Word = "fourteen";
 break;

 case 5:
 Word = "fifteen";
 break;

 case 6:
 Word = "sixteen";
 break;
 case 7:
 Word = "seventeen";
 break;

 case 8:
 Word = "eighteen";
 break;

 case 9:
 Word = "ninteen";
 break;


 }
 return Word;
 }
 }

}
</code></pre>

blocks|key|347631|text|完全递归版本：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|347632|private+static+string[]+ones+=+{
++++"zero",+"one",+"two",+"three",+"four",+"five",+"six",+"seven",+"eight",+"nine",+
++++"ten",+"eleven",+"twelve",+"thirteen",+"fourteen",+"fifteen",+"sixteen",+"seventeen",+"eighteen",+"nineteen",
};

private+static+string[]+tens+=+{+"zero",+"ten",+"twenty",+"thirty",+"forty",+"fifty",+"sixty",+"seventy",+"eighty",+"ninety"+};

private+static+string[]+thous+=+{+"hundred",+"thousand",+"million",+"billion",+"trillion",+"quadrillion"+};

private+static+string+fmt_negative+=+"negative+{0}";
private+static+string+fmt_dollars_and_cents+=+"{0}+dollars+and+{1}+cents";
private+static+string+fmt_tens_ones+=+"{0}-{1}";+//+e.g.+for+twenty-one,+thirty-two+etc.+You+might+want+to+use+an+en-dash+or+em-dash+instead+of+a+hyphen.
private+static+string+fmt_large_small+=+"{0}+{1}";+//+stitches+together+the+large+and+small+part+of+a+number,+like+"{three+thousand}+{five+hundred+forty+two}"
private+static+string+fmt_amount_scale+=+"{0}+{1}";+//+adds+the+scale+to+the+number,+e.g.+"{three}+{million}";

public+static+string+ToWords(decimal+number)+{
++++if+(number+<+0)
++++++++return+string.format(fmt_negative,+ToWords(Math.Abs(number)));

++++int+intPortion+=+(int)number;
++++int+decPortion+=+(int)((number+-+intPortion)+*+(decimal)+100);

++++return+string.Format(fmt_dollars_and_cents,+ToWords(intPortion),+ToWords(decPortion));
}

private+static+string+ToWords(int+number,+string+appendScale+=+"")+{
++++string+numString+=+"";
++++//+if+the+number+is+less+than+one+hundred,+then+we're+mostly+just+pulling+out+constants+from+the+ones+and+tens+dictionaries
++++if+(number+<+100)+{
++++++++if+(number+<+20)
++++++++++++numString+=+ones[number];
++++++++else+{
++++++++++++numString+=+tens[number+/+10];
++++++++++++if+((number+%25+10)+>+0)
++++++++++++++++numString+=+string.Format(fmt_tens_ones,+numString,+ones[number+%25+10]);
++++++++}
++++}+else+{
++++++++int+pow+=+0;+//+we'll+divide+the+number+by+pow+to+figure+out+the+next+chunk
++++++++string+powStr+=+"";+//+powStr+will+be+the+scale+that+we+append+to+the+string+e.g.+"hundred",+"thousand",+etc.

++++++++if+(number+<+1000)+{+//+number+is+between+100+and+1000
++++++++++++pow+=+100;+//+so+we'll+be+dividing+by+one+hundred
++++++++++++powStr+=+thous[0];+//+and+appending+the+string+"hundred"
++++++++}+else+{+//+find+the+scale+of+the+number
++++++++++++//+log+will+be+1,+2,+3+for+1_000,+1_000_000,+1_000_000_000,+etc.
++++++++++++int+log+=+(int)Math.Log(number,+1000);
++++++++++++//+pow+will+be+1_000,+1_000_000,+1_000_000_000+etc.
++++++++++++pow+=+(int)Math.Pow(1000,+log);
++++++++++++//+powStr+will+be+thousand,+million,+billion+etc.
++++++++++++powStr+=+thous[log];
++++++++}

++++++++//+we+take+the+quotient+and+the+remainder+after+dividing+by+pow,+and+call+ToWords+on+each+to+handle+cases+like+"{five+thousand}+{thirty+two}"+(curly+brackets+added+for+emphasis)
++++++++numString+=+string.Format(fmt_large_small,+ToWords(number+/+pow,+powStr),+ToWords(number+%25+pow)).Trim();
++++}

++++//+and+after+all+of+this,+if+we+were+passed+in+a+scale+from+above,+we+append+it+to+the+current+number+"{five}+{thousand}"
++++return+string.Format(fmt_amount_scale,+numString,+appendScale).Trim();
}|code-block|syntax|javascript|347633|电流最高可达(短期)万亿。只需更改thous变量，就可以添加额外的支持(对于更大的数字，或者对long+scale)。|offset|length|style|CODE|347634|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Long_and_short_scales^0|0|0|H|5|1B|A|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@$I|X|J|Y|K|L]]|9|@$I|Z|J|10|1|11]]|A|$]]|$1|M|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]]]

Fully recursive version:

<pre><code>private static string[] ones = {
 "zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine", 
 "ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen",
};

private static string[] tens = { "zero", "ten", "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety" };

private static string[] thous = { "hundred", "thousand", "million", "billion", "trillion", "quadrillion" };

private static string fmt_negative = "negative {0}";
private static string fmt_dollars_and_cents = "{0} dollars and {1} cents";
private static string fmt_tens_ones = "{0}-{1}"; // e.g. for twenty-one, thirty-two etc. You might want to use an en-dash or em-dash instead of a hyphen.
private static string fmt_large_small = "{0} {1}"; // stitches together the large and small part of a number, like "{three thousand} {five hundred forty two}"
private static string fmt_amount_scale = "{0} {1}"; // adds the scale to the number, e.g. "{three} {million}";

public static string ToWords(decimal number) {
 if (number &lt; 0)
 return string.format(fmt_negative, ToWords(Math.Abs(number)));

 int intPortion = (int)number;
 int decPortion = (int)((number - intPortion) * (decimal) 100);

 return string.Format(fmt_dollars_and_cents, ToWords(intPortion), ToWords(decPortion));
}

private static string ToWords(int number, string appendScale = "") {
 string numString = "";
 // if the number is less than one hundred, then we're mostly just pulling out constants from the ones and tens dictionaries
 if (number &lt; 100) {
 if (number &lt; 20)
 numString = ones[number];
 else {
 numString = tens[number / 10];
 if ((number % 10) &gt; 0)
 numString = string.Format(fmt_tens_ones, numString, ones[number % 10]);
 }
 } else {
 int pow = 0; // we'll divide the number by pow to figure out the next chunk
 string powStr = ""; // powStr will be the scale that we append to the string e.g. "hundred", "thousand", etc.

 if (number &lt; 1000) { // number is between 100 and 1000
 pow = 100; // so we'll be dividing by one hundred
 powStr = thous[0]; // and appending the string "hundred"
 } else { // find the scale of the number
 // log will be 1, 2, 3 for 1_000, 1_000_000, 1_000_000_000, etc.
 int log = (int)Math.Log(number, 1000);
 // pow will be 1_000, 1_000_000, 1_000_000_000 etc.
 pow = (int)Math.Pow(1000, log);
 // powStr will be thousand, million, billion etc.
 powStr = thous[log];
 }

 // we take the quotient and the remainder after dividing by pow, and call ToWords on each to handle cases like "{five thousand} {thirty two}" (curly brackets added for emphasis)
 numString = string.Format(fmt_large_small, ToWords(number / pow, powStr), ToWords(number % pow)).Trim();
 }

 // and after all of this, if we were passed in a scale from above, we append it to the current number "{five} {thousand}"
 return string.Format(fmt_amount_scale, numString, appendScale).Trim();
}
</code></pre>

Current works up to the (short scale) quadrillions. Additional support (for larger numbers, or for the <a href="http://en.wikipedia.org/wiki/Long_and_short_scales" rel="nofollow noreferrer">long scale</a>) can be added simply by changing the <code>thous</code> variable.

blocks|key|3341045|text|目前最好、最健壮的库无疑是Humanizer。它是开源的，可以作为nuget使用：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3341046|Console.WriteLine(4567788.ToWords());+//+=>+four+million+five+hundred+and+sixty-seven+thousand+seven+hundred+and+eighty-eight|code-block|syntax|javascript|3341047|它还具有广泛的工具，可以解决每个应用程序在string、enum、DateTime、TimeSpan等方面遇到的小问题，并支持多种不同的语言。|style|CODE|3341048|Console.WriteLine(4567788.ToOrdinalWords().Underscore().Hyphenate().ApplyCase(LetterCasing.AllCaps));+//+=>+FOUR-MILLION-FIVE-HUNDRED-AND-SIXTY-SEVEN-THOUSAND-SEVEN-HUNDRED-AND-EIGHTY-EIGHTH|3341049|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/MehdiK/Humanizer^0|D|9|0|0|0|L|6|S|4|X|8|16|8|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@$A|X|B|Y|1|Z]]|C|$]]|$1|D|3|E|5|F|7|10|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|11|8|@$A|12|B|13|K|L]|$A|14|B|15|K|L]|$A|16|B|17|K|L]|$A|18|B|19|K|L]]|9|@]|C|$]]|$1|M|3|N|5|F|7|1A|8|@]|9|@]|C|$G|H]]|$1|O|3|-4|5|6|7|1B|8|@]|9|@]|C|$]]]|P|$Q|$5|R|S|T|C|$U|V]]]]

Currently the best, most robust, library for this is definitely <a href="https://github.com/MehdiK/Humanizer">Humanizer</a>. It's open sourced and available as a nuget:

<pre><code>Console.WriteLine(4567788.ToWords()); // =&gt; four million five hundred and sixty-seven thousand seven hundred and eighty-eight
</code></pre>

It also has a wide range of tools solving the small problems every application has with <code>string</code>s, <code>enum</code>s, <code>DateTime</code>s, <code>TimeSpan</code>s and so forth, and supports many different languages.

<pre><code>Console.WriteLine(4567788.ToOrdinalWords().Underscore().Hyphenate().ApplyCase(LetterCasing.AllCaps)); // =&gt; FOUR-MILLION-FIVE-HUNDRED-AND-SIXTY-SEVEN-THOUSAND-SEVEN-HUNDRED-AND-EIGHTY-EIGHTH
</code></pre>

blocks|key|3341079|text|以防有人想要JavaScript版本|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3341080|Number.prototype.numberToWords+=+function+()+{
++++var+unitsMap+=+["zero",+"one",+"two",+"three",+"four",+"five",+"six",+"seven",+"eight",+"nine",+"ten",+"eleven",+"twelve",+"thirteen",+"fourteen",+"fifteen",+"sixteen",+"seventeen",+"eighteen",+"nineteen"];
++++var+tensMap+=+["zero",+"ten",+"twenty",+"thirty",+"forty",+"fifty",+"sixty",+"seventy",+"eighty",+"ninety"];

++++var+num+=+this.valueOf();
++++if+(Math.round(num+==+0))+{
++++++++return+"zero";
++++}
++++if+(num+<+0)+{
++++++++var+positivenum+=+Math.abs(num);
++++++++return+"minus+"+%2B+Number(positivenum).numberToWords();
++++}
++++var+words+=+"";
++++if+(Math.floor(num+/+1000000)+>+0)+{
++++++++words+%2B=+Math.floor(num+/+1000000).numberToWords()+%2B+"+million+";
++++++++num+=+Math.floor(num+%25+1000000);
++++}
++++if+(Math.floor(num+/+1000)+>+0)+{
++++++++words+%2B=+Math.floor(num+/+1000).numberToWords()+%2B+"+thousand+";
++++++++num+=+Math.floor(num+%25+1000);
++++}
++++if+(Math.floor(num+/+100)+>+0)+{
++++++++words+%2B=+Math.floor(num+/+100).numberToWords()+%2B+"+hundred+";
++++++++num+=+Math.floor(num+%25+100);
++++}
++++if+(Math.floor(num+>+0))+{
++++++++if+(words+!=+"")+{
++++++++++++words+%2B=+"and+";
++++++++}
++++++++if+(num+<+20)+{
++++++++words+%2B=+unitsMap[num];
++++++++}
++++++++else+{
++++++++++++words+%2B=+tensMap[Math.floor(num+/+10)];
++++++++++++if+((num+%25+10)+>+0)+{
++++++++++++++++words+%2B=+"-"+%2B+unitsMap[Math.round(num+%25+10)];
++++++++++++}
++++++++}
++++}
++++return+words.trim();
}|code-block|syntax|javascript|3341081|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

In case anyone wants a JavaScript version

<pre><code>Number.prototype.numberToWords = function () {
 var unitsMap = ["zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen"];
 var tensMap = ["zero", "ten", "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety"];

 var num = this.valueOf();
 if (Math.round(num == 0)) {
 return "zero";
 }
 if (num &lt; 0) {
 var positivenum = Math.abs(num);
 return "minus " + Number(positivenum).numberToWords();
 }
 var words = "";
 if (Math.floor(num / 1000000) &gt; 0) {
 words += Math.floor(num / 1000000).numberToWords() + " million ";
 num = Math.floor(num % 1000000);
 }
 if (Math.floor(num / 1000) &gt; 0) {
 words += Math.floor(num / 1000).numberToWords() + " thousand ";
 num = Math.floor(num % 1000);
 }
 if (Math.floor(num / 100) &gt; 0) {
 words += Math.floor(num / 100).numberToWords() + " hundred ";
 num = Math.floor(num % 100);
 }
 if (Math.floor(num &gt; 0)) {
 if (words != "") {
 words += "and ";
 }
 if (num &lt; 20) {
 words += unitsMap[num];
 }
 else {
 words += tensMap[Math.floor(num / 10)];
 if ((num % 10) &gt; 0) {
 words += "-" + unitsMap[Math.round(num % 10)];
 }
 }
 }
 return words.trim();
}
</code></pre>

blocks|key|350147|text|这个类完美地转换你的浮点数或双精度(直到2精度)。只需将其复制并粘贴到您的IDE中，即可查看结果。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|350148|class+ConversionClass
{
++++private+static+Dictionary<int,+string>+InitialNumbers+=+new+Dictionary<int,+string>();
++++private+static+Dictionary<int,+string>+MultipleOfTen+=+new+Dictionary<int,+string>();
++++private+static+Dictionary<int,+string>+MultipleOfHundered+=+new+Dictionary<int,+string>();

++++private+static+void+InitializeStatic()
++++{
++++++++//InitialNumbers.Add(0,+"zero");
++++++++InitialNumbers.Add(1,+"one");
++++++++InitialNumbers.Add(2,+"two");
++++++++InitialNumbers.Add(3,+"three");
++++++++InitialNumbers.Add(4,+"four");
++++++++InitialNumbers.Add(5,+"five");
++++++++InitialNumbers.Add(6,+"six");
++++++++InitialNumbers.Add(7,+"seven");
++++++++InitialNumbers.Add(8,+"eight");
++++++++InitialNumbers.Add(9,+"nine");
++++++++InitialNumbers.Add(10,+"ten");
++++++++InitialNumbers.Add(11,+"eleven");
++++++++InitialNumbers.Add(12,+"tweleve");
++++++++InitialNumbers.Add(13,+"thirteen");
++++++++InitialNumbers.Add(14,+"fourteen");
++++++++InitialNumbers.Add(15,+"fifteen");
++++++++InitialNumbers.Add(16,+"sixteen");
++++++++InitialNumbers.Add(17,+"seventeen");
++++++++InitialNumbers.Add(18,+"eighteen");
++++++++InitialNumbers.Add(19,+"nineteen");

++++++++MultipleOfTen.Add(1,+"ten");
++++++++MultipleOfTen.Add(2,+"twenty");
++++++++MultipleOfTen.Add(3,+"thirty");
++++++++MultipleOfTen.Add(4,+"fourty");
++++++++MultipleOfTen.Add(5,+"fifty");
++++++++MultipleOfTen.Add(6,+"sixty");
++++++++MultipleOfTen.Add(7,+"seventy");
++++++++MultipleOfTen.Add(8,+"eighty");
++++++++MultipleOfTen.Add(9,+"ninety");

++++++++MultipleOfHundered.Add(2,+"hundred");++++++++++++++++++++++//++++++++++++++++100
++++++++MultipleOfHundered.Add(3,+"thousand");+++++++++++++++++++++//++++++++++++++1+000
++++++++MultipleOfHundered.Add(4,+"thousand");+++++++++++++++++++++//+++++++++++++10+000
++++++++MultipleOfHundered.Add(5,+"thousand");+++++++++++++++++++++//++++++++++++100+000
++++++++MultipleOfHundered.Add(6,+"million");++++++++++++++++++++++//++++++++++1+000+000
++++++++MultipleOfHundered.Add(7,+"million");++++++++++++++++++++++//++++++++100+000+000
++++++++MultipleOfHundered.Add(8,+"million");++++++++++++++++++++++//++++++1+000+000+000
++++++++MultipleOfHundered.Add(9,+"billion");++++++++++++++++++++++//++1+000+000+000+000
++++}

++++public+static+void+Main()
++++{
++++++++InitializeStatic();
++++++++Console.WriteLine("Enter+number+:");
++++++++var+userInput+=+Console.ReadLine();
++++++++double+userValue+;
++++++++if+(double.TryParse(userInput,+out+userValue))++//+userValue+=+193524019.50
++++++++{
++++++++++++int+decimalPortion+=+(int)userValue;
++++++++++++//var+fractionPortion+=+Math.Ceiling(((userValue+<+1.0)+?+userValue+:+(userValue+%25+Math.Floor(userValue)))+*+100);
++++++++++++int+fractionPortion+=+(int)(userValue+*+100)+-+((int)userValue+*+100);

++++++++++++int+digit;+int+power;
++++++++++++StringBuilder+numberInText+=+new+StringBuilder();

++++++++++++while+(decimalPortion+>+0)
++++++++++++{
++++++++++++++++GetDigitAndPower(decimalPortion,+out+digit,+out+power);
++++++++++++++++numberInText.Append(ConvertToText(ref+decimalPortion,+ref+digit,+ref+power));
++++++++++++++++if+(decimalPortion+>+0)
++++++++++++++++{
++++++++++++++++++++decimalPortion+=+GetReminder(decimalPortion,+digit,+power);
++++++++++++++++}
++++++++++++}
++++++++++++numberInText.Append("+point+");
++++++++++++while+(fractionPortion+>+0)
++++++++++++{
++++++++++++++++GetDigitAndPower(fractionPortion,+out+digit,+out+power);
++++++++++++++++numberInText.Append(ConvertToText(ref+fractionPortion,+ref+digit,+ref+power));
++++++++++++++++if+(fractionPortion+>+0)
++++++++++++++++{
++++++++++++++++++++fractionPortion+=+GetReminder(fractionPortion,+digit,+power);
++++++++++++++++}
++++++++++++}

++++++++++++Console.WriteLine(numberInText.ToString());
++++++++}
++++++++Console.ReadKey();
++++}

++++private+static+int+GetReminder(int+orgValue,+int+digit,+int+power)
++++{
++++++++int+returningValue+=+orgValue+-+(digit+*+(int)Math.Pow(10,+power));
++++++++return+returningValue;
++++}

++++private+static+void+GetDigitAndPower(int+originalValue,+out+int+digit,+out+int+power)
++++{
++++++++for+(power+=+0,+digit+=+0;+power+<+10;+power%2B%2B)
++++++++{
++++++++++++var+divisionFactor+=+(int)Math.Pow(10,+power);
++++++++++++int+operationalValue+=+(originalValue+/+divisionFactor);
++++++++++++if+(operationalValue+<=+0)
++++++++++++{
++++++++++++++++power+=+power+-+1;
++++++++++++++++digit+=+(int)(originalValue+/+Math.Pow(10,+power));
++++++++++++++++break;
++++++++++++}
++++++++}+
++++}

++++private+static+string+ConvertToText(ref+int+orgValue,+ref+int+digit,+ref+int+power)
++++{
++++++++string+numberToText+=+string.Empty;

++++++++if+(power+<+2)
++++++++{
++++++++++++if+(InitialNumbers.ContainsKey(orgValue))
++++++++++++{
++++++++++++++++//This+is+for+number+1+to+19
++++++++++++++++numberToText+=+InitialNumbers[orgValue];
++++++++++++++++orgValue+=+0;
++++++++++++}
++++++++++++else+if+(MultipleOfTen.ContainsKey(digit))
++++++++++++{
++++++++++++++++//This+is+for+multiple+of+10+(20,30,..90)
++++++++++++++++numberToText+=+MultipleOfTen[digit];
++++++++++++}
++++++++}
++++++++else
++++++++{
++++++++++++if+(power+<+4)
++++++++++++{
++++++++++++++++numberToText+=+string.Format("{0}+{1}",+InitialNumbers[digit],+MultipleOfHundered[power]);
++++++++++++}
++++++++++++else
++++++++++++{
++++++++++++++++StringBuilder+sb+=+new+StringBuilder();
++++++++++++++++int+multiplicationFactor+=+power+/+3;
++++++++++++++++int+innerOrgValue+=+(int)+(orgValue+/+Math.Pow(10,+(multiplicationFactor+*+3)));
++++++++++++++++digit+=+innerOrgValue;
++++++++++++++++var+multiple+=+MultipleOfHundered[power];
++++++++++++++++power+=+power+-+((int)Math.Ceiling(Math.Log10(innerOrgValue))+-+1);

++++++++++++++++int+innerPower+=+0;
++++++++++++++++int+innerDigit+=+0;
++++++++++++++++while+(innerOrgValue+>+0)
++++++++++++++++{
++++++++++++++++++++GetDigitAndPower(innerOrgValue,+out+innerDigit,+out+innerPower);
++++++++++++++++++++var+text+=+ConvertToText(ref+innerOrgValue,+ref+innerDigit,+ref+innerPower);
++++++++++++++++++++sb.Append(text);
++++++++++++++++++++sb.Append("+");
++++++++++++++++++++if+(innerOrgValue+>+0)
++++++++++++++++++++{
++++++++++++++++++++++++innerOrgValue+=+GetReminder(innerOrgValue,+innerDigit,+innerPower);
++++++++++++++++++++}
++++++++++++++++}
++++++++++++++++sb.Append(multiple);
++++++++++++++++numberToText+=+sb.ToString();

++++++++++++}
++++++++}

++++++++return+numberToText+%2B+"+";
++++}

}|code-block|syntax|javascript|350149|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This class perfectly converts your float or double (till 2 precision).
Just copy and paste in your IDE and see the result.

<pre><code>class ConversionClass
{
 private static Dictionary&lt;int, string&gt; InitialNumbers = new Dictionary&lt;int, string&gt;();
 private static Dictionary&lt;int, string&gt; MultipleOfTen = new Dictionary&lt;int, string&gt;();
 private static Dictionary&lt;int, string&gt; MultipleOfHundered = new Dictionary&lt;int, string&gt;();

 private static void InitializeStatic()
 {
 //InitialNumbers.Add(0, "zero");
 InitialNumbers.Add(1, "one");
 InitialNumbers.Add(2, "two");
 InitialNumbers.Add(3, "three");
 InitialNumbers.Add(4, "four");
 InitialNumbers.Add(5, "five");
 InitialNumbers.Add(6, "six");
 InitialNumbers.Add(7, "seven");
 InitialNumbers.Add(8, "eight");
 InitialNumbers.Add(9, "nine");
 InitialNumbers.Add(10, "ten");
 InitialNumbers.Add(11, "eleven");
 InitialNumbers.Add(12, "tweleve");
 InitialNumbers.Add(13, "thirteen");
 InitialNumbers.Add(14, "fourteen");
 InitialNumbers.Add(15, "fifteen");
 InitialNumbers.Add(16, "sixteen");
 InitialNumbers.Add(17, "seventeen");
 InitialNumbers.Add(18, "eighteen");
 InitialNumbers.Add(19, "nineteen");

 MultipleOfTen.Add(1, "ten");
 MultipleOfTen.Add(2, "twenty");
 MultipleOfTen.Add(3, "thirty");
 MultipleOfTen.Add(4, "fourty");
 MultipleOfTen.Add(5, "fifty");
 MultipleOfTen.Add(6, "sixty");
 MultipleOfTen.Add(7, "seventy");
 MultipleOfTen.Add(8, "eighty");
 MultipleOfTen.Add(9, "ninety");

 MultipleOfHundered.Add(2, "hundred"); // 100
 MultipleOfHundered.Add(3, "thousand"); // 1 000
 MultipleOfHundered.Add(4, "thousand"); // 10 000
 MultipleOfHundered.Add(5, "thousand"); // 100 000
 MultipleOfHundered.Add(6, "million"); // 1 000 000
 MultipleOfHundered.Add(7, "million"); // 100 000 000
 MultipleOfHundered.Add(8, "million"); // 1 000 000 000
 MultipleOfHundered.Add(9, "billion"); // 1 000 000 000 000
 }

 public static void Main()
 {
 InitializeStatic();
 Console.WriteLine("Enter number :");
 var userInput = Console.ReadLine();
 double userValue ;
 if (double.TryParse(userInput, out userValue)) // userValue = 193524019.50
 {
 int decimalPortion = (int)userValue;
 //var fractionPortion = Math.Ceiling(((userValue &lt; 1.0) ? userValue : (userValue % Math.Floor(userValue))) * 100);
 int fractionPortion = (int)(userValue * 100) - ((int)userValue * 100);

 int digit; int power;
 StringBuilder numberInText = new StringBuilder();

 while (decimalPortion &gt; 0)
 {
 GetDigitAndPower(decimalPortion, out digit, out power);
 numberInText.Append(ConvertToText(ref decimalPortion, ref digit, ref power));
 if (decimalPortion &gt; 0)
 {
 decimalPortion = GetReminder(decimalPortion, digit, power);
 }
 }
 numberInText.Append(" point ");
 while (fractionPortion &gt; 0)
 {
 GetDigitAndPower(fractionPortion, out digit, out power);
 numberInText.Append(ConvertToText(ref fractionPortion, ref digit, ref power));
 if (fractionPortion &gt; 0)
 {
 fractionPortion = GetReminder(fractionPortion, digit, power);
 }
 }

 Console.WriteLine(numberInText.ToString());
 }
 Console.ReadKey();
 }

 private static int GetReminder(int orgValue, int digit, int power)
 {
 int returningValue = orgValue - (digit * (int)Math.Pow(10, power));
 return returningValue;
 }

 private static void GetDigitAndPower(int originalValue, out int digit, out int power)
 {
 for (power = 0, digit = 0; power &lt; 10; power++)
 {
 var divisionFactor = (int)Math.Pow(10, power);
 int operationalValue = (originalValue / divisionFactor);
 if (operationalValue &lt;= 0)
 {
 power = power - 1;
 digit = (int)(originalValue / Math.Pow(10, power));
 break;
 }
 } 
 }

 private static string ConvertToText(ref int orgValue, ref int digit, ref int power)
 {
 string numberToText = string.Empty;

 if (power &lt; 2)
 {
 if (InitialNumbers.ContainsKey(orgValue))
 {
 //This is for number 1 to 19
 numberToText = InitialNumbers[orgValue];
 orgValue = 0;
 }
 else if (MultipleOfTen.ContainsKey(digit))
 {
 //This is for multiple of 10 (20,30,..90)
 numberToText = MultipleOfTen[digit];
 }
 }
 else
 {
 if (power &lt; 4)
 {
 numberToText = string.Format("{0} {1}", InitialNumbers[digit], MultipleOfHundered[power]);
 }
 else
 {
 StringBuilder sb = new StringBuilder();
 int multiplicationFactor = power / 3;
 int innerOrgValue = (int) (orgValue / Math.Pow(10, (multiplicationFactor * 3)));
 digit = innerOrgValue;
 var multiple = MultipleOfHundered[power];
 power = power - ((int)Math.Ceiling(Math.Log10(innerOrgValue)) - 1);

 int innerPower = 0;
 int innerDigit = 0;
 while (innerOrgValue &gt; 0)
 {
 GetDigitAndPower(innerOrgValue, out innerDigit, out innerPower);
 var text = ConvertToText(ref innerOrgValue, ref innerDigit, ref innerPower);
 sb.Append(text);
 sb.Append(" ");
 if (innerOrgValue &gt; 0)
 {
 innerOrgValue = GetReminder(innerOrgValue, innerDigit, innerPower);
 }
 }
 sb.Append(multiple);
 numberToText = sb.ToString();

 }
 }

 return numberToText + " ";
 }

}
</code></pre>

blocks|key|350156|text|虽然这是一个老问题，但我已经用更详细的方法实现了这个功能|type|unstyled|depth|inlineStyleRanges|entityRanges|data|350157|public+static+class+NumberToWord
++++{
++++++++private+static+readonly+Dictionary<long,+string>+MyDictionary+=+new+Dictionary<long,+string>();

++++++++static+NumberToWord()
++++++++{
++++++++++++MyDictionary.Add(1000000000000000,+"quadrillion");
++++++++++++MyDictionary.Add(1000000000000,+"trillion");
++++++++++++MyDictionary.Add(1000000000,+"billion");
++++++++++++MyDictionary.Add(1000000,+"million");
++++++++++++MyDictionary.Add(1000,+"thousand");
++++++++++++MyDictionary.Add(100,+"hundread");
++++++++++++MyDictionary.Add(90,+"ninety");
++++++++++++MyDictionary.Add(80,+"eighty");
++++++++++++MyDictionary.Add(70,+"seventy");
++++++++++++MyDictionary.Add(60,+"sixty");
++++++++++++MyDictionary.Add(50,+"fifty");
++++++++++++MyDictionary.Add(40,+"fourty");
++++++++++++MyDictionary.Add(30,+"thirty");
++++++++++++MyDictionary.Add(20,+"twenty");
++++++++++++MyDictionary.Add(19,+"nineteen");
++++++++++++MyDictionary.Add(18,+"eighteen");
++++++++++++MyDictionary.Add(17,+"seventeen");
++++++++++++MyDictionary.Add(16,+"sixteen");
++++++++++++MyDictionary.Add(15,+"fifteen");
++++++++++++MyDictionary.Add(14,+"fourteen");
++++++++++++MyDictionary.Add(13,+"thirteen");
++++++++++++MyDictionary.Add(12,+"twelve");
++++++++++++MyDictionary.Add(11,+"eleven");
++++++++++++MyDictionary.Add(10,+"ten");
++++++++++++MyDictionary.Add(9,+"nine");
++++++++++++MyDictionary.Add(8,+"eight");
++++++++++++MyDictionary.Add(7,+"seven");
++++++++++++MyDictionary.Add(6,+"six");
++++++++++++MyDictionary.Add(5,+"five");
++++++++++++MyDictionary.Add(4,+"four");
++++++++++++MyDictionary.Add(3,+"three");
++++++++++++MyDictionary.Add(2,+"two");
++++++++++++MyDictionary.Add(1,+"one");
++++++++++++MyDictionary.Add(0,+"zero");
++++++++}

++++++++///+<summary>
++++++++///+To+the+verbal.
++++++++///+</summary>
++++++++///+<param+name="value">The+value.</param>
++++++++///+<returns></returns>
++++++++public+static+string+ToVerbal(this+int+value)
++++++++{
++++++++++++return+ToVerbal((long)+value);
++++++++}

++++++++///+<summary>
++++++++///+To+the+verbal.
++++++++///+</summary>
++++++++///+<param+name="value">The+value.</param>
++++++++///+<returns></returns>
++++++++public+static+string+ToVerbal(this+long+value)
++++++++{
++++++++++++if+(value+==+0)+return+MyDictionary[value];

++++++++++++if+(value+<+0)
++++++++++++++++return+$"+negative+{ToVerbal(Math.Abs(value))}";

++++++++++++var+builder+=+new+StringBuilder();

++++++++++++for+(var+i+=+1000000000000000;+i+>=+1000;+i+=+i/1000)
++++++++++++++++value+=+ConstructWord(value,+builder,+i);

++++++++++++value+=+ConstructWord(value,+builder,+100);

++++++++++++for+(var+i+=+90;+i+>=+20;+i+=+i+-+10)
++++++++++++++++value+=+ConstructWordForTwoDigit(value,+builder,+i);

++++++++++++if+(MyDictionary.ContainsKey(value))
++++++++++++++++builder.AppendFormat("{0}"+%2B+MyDictionary[value],+builder.Length+>+0+
++++++++++++++++++++?+"+"+
++++++++++++++++++++:+string.Empty);

++++++++++++return+builder.ToString();
++++++++}

++++++++private+static+long+ConstructWord(long+value,+StringBuilder+builder,+long+key)
++++++++{
++++++++++++if+(value+>=+key)
++++++++++++{
++++++++++++++++var+unit+=+(int)+(value/key);
++++++++++++++++value+-=+unit*key;
++++++++++++++++builder.AppendFormat("+{0}+{1}+"+%2B+MyDictionary[key],+builder.Length+>+0
++++++++++++++++++++?+",+"
++++++++++++++++++++:+string.Empty,+ToVerbal(unit));
++++++++++++}
++++++++++++return+value;
++++++++}
++++++++private+static+long+ConstructWordForTwoDigit(long+value,+StringBuilder+builder,+long+key)
++++++++{
++++++++++++if+(value+>=+key)
++++++++++++{
++++++++++++++++value+-=+key;
++++++++++++++++builder.AppendFormat("+{0}+"+%2B+MyDictionary[key],+builder.Length+>+0
++++++++++++++++++++?+"+"
++++++++++++++++++++:+string.Empty);
++++++++++++}
++++++++++++return+value;
++++++++}+
++++}|code-block|syntax|javascript|350158|仅供参考:我有用户字符串插值，仅在4.6.1中可用|350159|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Though this is kind of old question, I have implemented this functionality with more detailed approach

<pre><code>public static class NumberToWord
 {
 private static readonly Dictionary&lt;long, string&gt; MyDictionary = new Dictionary&lt;long, string&gt;();

 static NumberToWord()
 {
 MyDictionary.Add(1000000000000000, "quadrillion");
 MyDictionary.Add(1000000000000, "trillion");
 MyDictionary.Add(1000000000, "billion");
 MyDictionary.Add(1000000, "million");
 MyDictionary.Add(1000, "thousand");
 MyDictionary.Add(100, "hundread");
 MyDictionary.Add(90, "ninety");
 MyDictionary.Add(80, "eighty");
 MyDictionary.Add(70, "seventy");
 MyDictionary.Add(60, "sixty");
 MyDictionary.Add(50, "fifty");
 MyDictionary.Add(40, "fourty");
 MyDictionary.Add(30, "thirty");
 MyDictionary.Add(20, "twenty");
 MyDictionary.Add(19, "nineteen");
 MyDictionary.Add(18, "eighteen");
 MyDictionary.Add(17, "seventeen");
 MyDictionary.Add(16, "sixteen");
 MyDictionary.Add(15, "fifteen");
 MyDictionary.Add(14, "fourteen");
 MyDictionary.Add(13, "thirteen");
 MyDictionary.Add(12, "twelve");
 MyDictionary.Add(11, "eleven");
 MyDictionary.Add(10, "ten");
 MyDictionary.Add(9, "nine");
 MyDictionary.Add(8, "eight");
 MyDictionary.Add(7, "seven");
 MyDictionary.Add(6, "six");
 MyDictionary.Add(5, "five");
 MyDictionary.Add(4, "four");
 MyDictionary.Add(3, "three");
 MyDictionary.Add(2, "two");
 MyDictionary.Add(1, "one");
 MyDictionary.Add(0, "zero");
 }

 /// &lt;summary&gt;
 /// To the verbal.
 /// &lt;/summary&gt;
 /// &lt;param name="value"&gt;The value.&lt;/param&gt;
 /// &lt;returns&gt;&lt;/returns&gt;
 public static string ToVerbal(this int value)
 {
 return ToVerbal((long) value);
 }

 /// &lt;summary&gt;
 /// To the verbal.
 /// &lt;/summary&gt;
 /// &lt;param name="value"&gt;The value.&lt;/param&gt;
 /// &lt;returns&gt;&lt;/returns&gt;
 public static string ToVerbal(this long value)
 {
 if (value == 0) return MyDictionary[value];

 if (value &lt; 0)
 return $" negative {ToVerbal(Math.Abs(value))}";

 var builder = new StringBuilder();

 for (var i = 1000000000000000; i &gt;= 1000; i = i/1000)
 value = ConstructWord(value, builder, i);

 value = ConstructWord(value, builder, 100);

 for (var i = 90; i &gt;= 20; i = i - 10)
 value = ConstructWordForTwoDigit(value, builder, i);

 if (MyDictionary.ContainsKey(value))
 builder.AppendFormat("{0}" + MyDictionary[value], builder.Length &gt; 0 
 ? " " 
 : string.Empty);

 return builder.ToString();
 }

 private static long ConstructWord(long value, StringBuilder builder, long key)
 {
 if (value &gt;= key)
 {
 var unit = (int) (value/key);
 value -= unit*key;
 builder.AppendFormat(" {0} {1} " + MyDictionary[key], builder.Length &gt; 0
 ? ", "
 : string.Empty, ToVerbal(unit));
 }
 return value;
 }
 private static long ConstructWordForTwoDigit(long value, StringBuilder builder, long key)
 {
 if (value &gt;= key)
 {
 value -= key;
 builder.AppendFormat(" {0} " + MyDictionary[key], builder.Length &gt; 0
 ? " "
 : string.Empty);
 }
 return value;
 } 
 }
</code></pre>

FYI: i have user string interpolation which is only available in 4.6.1

blocks|key|3128317|text|占用较少代码的解决方案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3128318|最重要的部分只有几行：|3128319|static+Func<long,+string>+remainder+=+t+=>+t+>+0+?+"+"+%2B+ToEN(t)+:+"";

public+static+string+ToEN(this+long+val,+double+d+=+20,+long+th+=+20)
{
++++switch+((long)d)
++++{
++++++++case+20:+++return+val+>=+d+?+ToEN(val,+1e2)+++++++++++++:+en[val];
++++++++case+100:++return+val+>=+d+?+ToEN(val,+1e3,+100)++++++++:+en[val+/+10+*+10]+%2B+remainder(val+%25+10);
++++++++default:+++return+val+>=+d+?+ToEN(val,+d+*+1e3,(long)d)+:+ToEN(val+/+th)+%2B+"+"+%2B+en[th]+%2B+remainder(val+%25+th);
++++}
}|code-block|syntax|javascript|3128320|完整的代码可以在这里找到https://dotnetfiddle.net/wjr4hF|offset|length|3128321|entityMap|0|LINK|mutability|MUTABLE|url|https://dotnetfiddle.net/wjr4hF^0|0|0|0|C|V|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|W|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|X|8|@]|9|@$K|Y|L|Z|1|10]]|A|$]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]]]

Solution that takes up less code.

The most important part is only couple lines:

<pre><code>static Func&lt;long, string&gt; remainder = t =&gt; t &gt; 0 ? " " + ToEN(t) : "";

public static string ToEN(this long val, double d = 20, long th = 20)
{
 switch ((long)d)
 {
 case 20: return val &gt;= d ? ToEN(val, 1e2) : en[val];
 case 100: return val &gt;= d ? ToEN(val, 1e3, 100) : en[val / 10 * 10] + remainder(val % 10);
 default: return val &gt;= d ? ToEN(val, d * 1e3,(long)d) : ToEN(val / th) + " " + en[th] + remainder(val % th);
 }
}
</code></pre>

Full code is available here <a href="https://dotnetfiddle.net/wjr4hF" rel="nofollow noreferrer">https://dotnetfiddle.net/wjr4hF</a>

blocks|key|347731|text|下面的C#控制台应用程序代码将接受最多2位小数的货币值，并以英语打印出来。您可以将其作为实现您的结果的参考。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|347732|+++namespace+ConsoleApplication2
{
++++using+System;
++++using+System.Collections.Generic;
++++using+System.Linq;
++++using+System.Text.RegularExpressions;
++++class+Program
++++{
+++++++static+void+Main(string[]+args)
++++++++{
++++++++++++bool+repeat+=+true;
++++++++++++while+(repeat)
++++++++++++{
++++++++++++++++string+inputMonetaryValueInNumberic+=+string.Empty;
++++++++++++++++string+centPart+=+string.Empty;
++++++++++++++++string+dollarPart+=+string.Empty;
++++++++++++++++Console.Write("\nEnter+the+monetary+value+:+");
++++++++++++++++inputMonetaryValueInNumberic+=+Console.ReadLine();
++++++++++++++++inputMonetaryValueInNumberic+=+inputMonetaryValueInNumberic.TrimStart('0');

++++++++++++++++if+(ValidateInput(inputMonetaryValueInNumberic))
++++++++++++++++{

++++++++++++++++++++if+(inputMonetaryValueInNumberic.Contains('.'))
++++++++++++++++++++{
++++++++++++++++++++++++centPart+=+ProcessCents(inputMonetaryValueInNumberic.Substring(inputMonetaryValueInNumberic.IndexOf(".")+%2B+1));
++++++++++++++++++++++++dollarPart+=+ProcessDollar(inputMonetaryValueInNumberic.Substring(0,+inputMonetaryValueInNumberic.IndexOf(".")));
++++++++++++++++++++}
++++++++++++++++++++else
++++++++++++++++++++{
++++++++++++++++++++++++dollarPart+=+ProcessDollar(inputMonetaryValueInNumberic);
++++++++++++++++++++}
++++++++++++++++++++centPart+=+string.IsNullOrWhiteSpace(centPart)+?+string.Empty+:+"+and+"+%2B+centPart;
++++++++++++++++++++Console.WriteLine(string.Format("\n\n{0}{1}",+dollarPart,+centPart));
++++++++++++++++}
++++++++++++++++else
++++++++++++++++{
++++++++++++++++++++Console.WriteLine("Invalid+Input..");
++++++++++++++++}

++++++++++++++++Console.WriteLine("\n\nPress+any+key+to+continue+or+Escape+of+close+:+");
++++++++++++++++var+loop+=+Console.ReadKey();
++++++++++++++++repeat+=+!loop.Key.ToString().Contains("Escape");
++++++++++++++++Console.Clear();
++++++++++++}

++++++++}

++++++++private+static+string+ProcessCents(string+cents)
++++++++{
++++++++++++string+english+=+string.Empty;
++++++++++++string+dig3+=+Process3Digit(cents);
++++++++++++if+(!string.IsNullOrWhiteSpace(dig3))
++++++++++++{
++++++++++++++++dig3+=+string.Format("{0}+{1}",+dig3,+GetSections(0));
++++++++++++}
++++++++++++english+=+dig3+%2B+english;
++++++++++++return+english;
++++++++}
++++++++private+static+string+ProcessDollar(string+dollar)
++++++++{
++++++++++++string+english+=+string.Empty;
++++++++++++foreach+(var+item+in+Get3DigitList(dollar))
++++++++++++{
++++++++++++++++string+dig3+=+Process3Digit(item.Value);
++++++++++++++++if+(!string.IsNullOrWhiteSpace(dig3))
++++++++++++++++{
++++++++++++++++++++dig3+=+string.Format("{0}+{1}",+dig3,+GetSections(item.Key));
++++++++++++++++}
++++++++++++++++english+=+dig3+%2B+english;
++++++++++++}
++++++++++++return+english;
++++++++}
++++++++private+static+string+Process3Digit(string+digit3)
++++++++{
++++++++++++string+result+=+string.Empty;
++++++++++++if+(Convert.ToInt32(digit3)+!=+0)
++++++++++++{
++++++++++++++++int+place+=+0;
++++++++++++++++Stack<string>+monetaryValue+=+new+Stack<string>();
++++++++++++++++for+(int+i+=+digit3.Length+-+1;+i+>=+0;+i--)
++++++++++++++++{
++++++++++++++++++++place+%2B=+1;
++++++++++++++++++++string+stringValue+=+string.Empty;
++++++++++++++++++++switch+(place)
++++++++++++++++++++{
++++++++++++++++++++++++case+1:
++++++++++++++++++++++++++++stringValue+=+GetOnes(digit3[i].ToString());
++++++++++++++++++++++++++++break;
++++++++++++++++++++++++case+2:
++++++++++++++++++++++++++++int+tens+=+Convert.ToInt32(digit3[i]);
++++++++++++++++++++++++++++if+(tens+==+1)
++++++++++++++++++++++++++++{
++++++++++++++++++++++++++++++++if+(monetaryValue.Count+>+0)
++++++++++++++++++++++++++++++++{
++++++++++++++++++++++++++++++++++++monetaryValue.Pop();
++++++++++++++++++++++++++++++++}
++++++++++++++++++++++++++++++++stringValue+=+GetTens((digit3[i].ToString()+%2B+digit3[i+%2B+1].ToString()));
++++++++++++++++++++++++++++}
++++++++++++++++++++++++++++else
++++++++++++++++++++++++++++{
++++++++++++++++++++++++++++++++stringValue+=+GetTens(digit3[i].ToString());
++++++++++++++++++++++++++++}
++++++++++++++++++++++++++++break;
++++++++++++++++++++++++case+3:
++++++++++++++++++++++++++++stringValue+=+GetOnes(digit3[i].ToString());
++++++++++++++++++++++++++++if+(!string.IsNullOrWhiteSpace(stringValue))
++++++++++++++++++++++++++++{
++++++++++++++++++++++++++++++++string+postFixWith+=+"+Hundred";
++++++++++++++++++++++++++++++++if+(monetaryValue.Count+>+0)
++++++++++++++++++++++++++++++++{
++++++++++++++++++++++++++++++++++++postFixWith+=+postFixWith+%2B+"+And";
++++++++++++++++++++++++++++++++}
++++++++++++++++++++++++++++++++stringValue+%2B=+postFixWith;
++++++++++++++++++++++++++++}
++++++++++++++++++++++++++++break;
++++++++++++++++++++}
++++++++++++++++++++if+(!string.IsNullOrWhiteSpace(stringValue))
++++++++++++++++++++++++monetaryValue.Push(stringValue);
++++++++++++++++}
++++++++++++++++while+(monetaryValue.Count+>+0)
++++++++++++++++{
++++++++++++++++++++result+%2B=+"+"+%2B+monetaryValue.Pop().ToString().Trim();
++++++++++++++++}
++++++++++++}
++++++++++++return+result;
++++++++}
++++++++private+static+Dictionary<int,+string>+Get3DigitList(string+monetaryValueInNumberic)
++++++++{
++++++++++++Dictionary<int,+string>+hundredsStack+=+new+Dictionary<int,+string>();
++++++++++++int+counter+=+0;
++++++++++++while+(monetaryValueInNumberic.Length+>=+3)
++++++++++++{
++++++++++++++++string+digit3+=+monetaryValueInNumberic.Substring(monetaryValueInNumberic.Length+-+3,+3);
++++++++++++++++monetaryValueInNumberic+=+monetaryValueInNumberic.Substring(0,+monetaryValueInNumberic.Length+-+3);
++++++++++++++++hundredsStack.Add(%2B%2Bcounter,+digit3);
++++++++++++}
++++++++++++if+(monetaryValueInNumberic.Length+!=+0)
++++++++++++++++hundredsStack.Add(%2B%2Bcounter,+monetaryValueInNumberic);
++++++++++++return+hundredsStack;
++++++++}
++++++++private+static+string+GetTens(string+tensPlaceValue)
++++++++{
++++++++++++string+englishEquvalent+=+string.Empty;
++++++++++++int+value+=+Convert.ToInt32(tensPlaceValue);
++++++++++++Dictionary<int,+string>+tens+=+new+Dictionary<int,+string>();
++++++++++++tens.Add(2,+"Twenty");
++++++++++++tens.Add(3,+"Thirty");
++++++++++++tens.Add(4,+"Forty");
++++++++++++tens.Add(5,+"Fifty");
++++++++++++tens.Add(6,+"Sixty");
++++++++++++tens.Add(7,+"Seventy");
++++++++++++tens.Add(8,+"Eighty");
++++++++++++tens.Add(9,+"Ninty");
++++++++++++tens.Add(10,+"Ten");
++++++++++++tens.Add(11,+"Eleven");
++++++++++++tens.Add(12,+"Twelve");
++++++++++++tens.Add(13,+"Thrteen");
++++++++++++tens.Add(14,+"Fourteen");
++++++++++++tens.Add(15,+"Fifteen");
++++++++++++tens.Add(16,+"Sixteen");
++++++++++++tens.Add(17,+"Seventeen");
++++++++++++tens.Add(18,+"Eighteen");
++++++++++++tens.Add(19,+"Ninteen");
++++++++++++if+(tens.ContainsKey(value))
++++++++++++{
++++++++++++++++englishEquvalent+=+tens[value];
++++++++++++}

++++++++++++return+englishEquvalent;

++++++++}
++++++++private+static+string+GetOnes(string+onesPlaceValue)
++++++++{
++++++++++++int+value+=+Convert.ToInt32(onesPlaceValue);
++++++++++++string+englishEquvalent+=+string.Empty;
++++++++++++Dictionary<int,+string>+ones+=+new+Dictionary<int,+string>();
++++++++++++ones.Add(1,+"+One");
++++++++++++ones.Add(2,+"+Two");
++++++++++++ones.Add(3,+"+Three");
++++++++++++ones.Add(4,+"+Four");
++++++++++++ones.Add(5,+"+Five");
++++++++++++ones.Add(6,+"+Six");
++++++++++++ones.Add(7,+"+Seven");
++++++++++++ones.Add(8,+"+Eight");
++++++++++++ones.Add(9,+"+Nine");

++++++++++++if+(ones.ContainsKey(value))
++++++++++++{
++++++++++++++++englishEquvalent+=+ones[value];
++++++++++++}

++++++++++++return+englishEquvalent;
++++++++}
++++++++private+static+string+GetSections(int+section)
++++++++{
++++++++++++string+sectionName+=+string.Empty;
++++++++++++switch+(section)
++++++++++++{
++++++++++++++++case+0:
++++++++++++++++++++sectionName+=+"Cents";
++++++++++++++++++++break;
++++++++++++++++case+1:
++++++++++++++++++++sectionName+=+"Dollars";
++++++++++++++++++++break;
++++++++++++++++case+2:
++++++++++++++++++++sectionName+=+"Thousand";
++++++++++++++++++++break;
++++++++++++++++case+3:
++++++++++++++++++++sectionName+=+"Million";
++++++++++++++++++++break;
++++++++++++++++case+4:
++++++++++++++++++++sectionName+=+"Billion";
++++++++++++++++++++break;
++++++++++++++++case+5:
++++++++++++++++++++sectionName+=+"Trillion";
++++++++++++++++++++break;
++++++++++++++++case+6:
++++++++++++++++++++sectionName+=+"Zillion";
++++++++++++++++++++break;
++++++++++++}
++++++++++++return+sectionName;
++++++++}
++++++++private+static+bool+ValidateInput(string+input)
++++++++{
++++++++++++return+Regex.IsMatch(input,+"[0-9]{1,18}(\\.[0-9]{1,2})?"))
++++++++}
++++}
}|code-block|syntax|javascript|347733|​|347734|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

The following C# console app code will give accepts a monetary value in numbers up to 2 decimals and prints it in English. You can use it as a reference to achieve your results.
<code>

<pre><code> namespace ConsoleApplication2
{
 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text.RegularExpressions;
 class Program
 {
 static void Main(string[] args)
 {
 bool repeat = true;
 while (repeat)
 {
 string inputMonetaryValueInNumberic = string.Empty;
 string centPart = string.Empty;
 string dollarPart = string.Empty;
 Console.Write("\nEnter the monetary value : ");
 inputMonetaryValueInNumberic = Console.ReadLine();
 inputMonetaryValueInNumberic = inputMonetaryValueInNumberic.TrimStart('0');

 if (ValidateInput(inputMonetaryValueInNumberic))
 {

 if (inputMonetaryValueInNumberic.Contains('.'))
 {
 centPart = ProcessCents(inputMonetaryValueInNumberic.Substring(inputMonetaryValueInNumberic.IndexOf(".") + 1));
 dollarPart = ProcessDollar(inputMonetaryValueInNumberic.Substring(0, inputMonetaryValueInNumberic.IndexOf(".")));
 }
 else
 {
 dollarPart = ProcessDollar(inputMonetaryValueInNumberic);
 }
 centPart = string.IsNullOrWhiteSpace(centPart) ? string.Empty : " and " + centPart;
 Console.WriteLine(string.Format("\n\n{0}{1}", dollarPart, centPart));
 }
 else
 {
 Console.WriteLine("Invalid Input..");
 }

 Console.WriteLine("\n\nPress any key to continue or Escape of close : ");
 var loop = Console.ReadKey();
 repeat = !loop.Key.ToString().Contains("Escape");
 Console.Clear();
 }

 }

 private static string ProcessCents(string cents)
 {
 string english = string.Empty;
 string dig3 = Process3Digit(cents);
 if (!string.IsNullOrWhiteSpace(dig3))
 {
 dig3 = string.Format("{0} {1}", dig3, GetSections(0));
 }
 english = dig3 + english;
 return english;
 }
 private static string ProcessDollar(string dollar)
 {
 string english = string.Empty;
 foreach (var item in Get3DigitList(dollar))
 {
 string dig3 = Process3Digit(item.Value);
 if (!string.IsNullOrWhiteSpace(dig3))
 {
 dig3 = string.Format("{0} {1}", dig3, GetSections(item.Key));
 }
 english = dig3 + english;
 }
 return english;
 }
 private static string Process3Digit(string digit3)
 {
 string result = string.Empty;
 if (Convert.ToInt32(digit3) != 0)
 {
 int place = 0;
 Stack&lt;string&gt; monetaryValue = new Stack&lt;string&gt;();
 for (int i = digit3.Length - 1; i &gt;= 0; i--)
 {
 place += 1;
 string stringValue = string.Empty;
 switch (place)
 {
 case 1:
 stringValue = GetOnes(digit3[i].ToString());
 break;
 case 2:
 int tens = Convert.ToInt32(digit3[i]);
 if (tens == 1)
 {
 if (monetaryValue.Count &gt; 0)
 {
 monetaryValue.Pop();
 }
 stringValue = GetTens((digit3[i].ToString() + digit3[i + 1].ToString()));
 }
 else
 {
 stringValue = GetTens(digit3[i].ToString());
 }
 break;
 case 3:
 stringValue = GetOnes(digit3[i].ToString());
 if (!string.IsNullOrWhiteSpace(stringValue))
 {
 string postFixWith = " Hundred";
 if (monetaryValue.Count &gt; 0)
 {
 postFixWith = postFixWith + " And";
 }
 stringValue += postFixWith;
 }
 break;
 }
 if (!string.IsNullOrWhiteSpace(stringValue))
 monetaryValue.Push(stringValue);
 }
 while (monetaryValue.Count &gt; 0)
 {
 result += " " + monetaryValue.Pop().ToString().Trim();
 }
 }
 return result;
 }
 private static Dictionary&lt;int, string&gt; Get3DigitList(string monetaryValueInNumberic)
 {
 Dictionary&lt;int, string&gt; hundredsStack = new Dictionary&lt;int, string&gt;();
 int counter = 0;
 while (monetaryValueInNumberic.Length &gt;= 3)
 {
 string digit3 = monetaryValueInNumberic.Substring(monetaryValueInNumberic.Length - 3, 3);
 monetaryValueInNumberic = monetaryValueInNumberic.Substring(0, monetaryValueInNumberic.Length - 3);
 hundredsStack.Add(++counter, digit3);
 }
 if (monetaryValueInNumberic.Length != 0)
 hundredsStack.Add(++counter, monetaryValueInNumberic);
 return hundredsStack;
 }
 private static string GetTens(string tensPlaceValue)
 {
 string englishEquvalent = string.Empty;
 int value = Convert.ToInt32(tensPlaceValue);
 Dictionary&lt;int, string&gt; tens = new Dictionary&lt;int, string&gt;();
 tens.Add(2, "Twenty");
 tens.Add(3, "Thirty");
 tens.Add(4, "Forty");
 tens.Add(5, "Fifty");
 tens.Add(6, "Sixty");
 tens.Add(7, "Seventy");
 tens.Add(8, "Eighty");
 tens.Add(9, "Ninty");
 tens.Add(10, "Ten");
 tens.Add(11, "Eleven");
 tens.Add(12, "Twelve");
 tens.Add(13, "Thrteen");
 tens.Add(14, "Fourteen");
 tens.Add(15, "Fifteen");
 tens.Add(16, "Sixteen");
 tens.Add(17, "Seventeen");
 tens.Add(18, "Eighteen");
 tens.Add(19, "Ninteen");
 if (tens.ContainsKey(value))
 {
 englishEquvalent = tens[value];
 }

 return englishEquvalent;

 }
 private static string GetOnes(string onesPlaceValue)
 {
 int value = Convert.ToInt32(onesPlaceValue);
 string englishEquvalent = string.Empty;
 Dictionary&lt;int, string&gt; ones = new Dictionary&lt;int, string&gt;();
 ones.Add(1, " One");
 ones.Add(2, " Two");
 ones.Add(3, " Three");
 ones.Add(4, " Four");
 ones.Add(5, " Five");
 ones.Add(6, " Six");
 ones.Add(7, " Seven");
 ones.Add(8, " Eight");
 ones.Add(9, " Nine");

 if (ones.ContainsKey(value))
 {
 englishEquvalent = ones[value];
 }

 return englishEquvalent;
 }
 private static string GetSections(int section)
 {
 string sectionName = string.Empty;
 switch (section)
 {
 case 0:
 sectionName = "Cents";
 break;
 case 1:
 sectionName = "Dollars";
 break;
 case 2:
 sectionName = "Thousand";
 break;
 case 3:
 sectionName = "Million";
 break;
 case 4:
 sectionName = "Billion";
 break;
 case 5:
 sectionName = "Trillion";
 break;
 case 6:
 sectionName = "Zillion";
 break;
 }
 return sectionName;
 }
 private static bool ValidateInput(string input)
 {
 return Regex.IsMatch(input, "[0-9]{1,18}(\\.[0-9]{1,2})?"))
 }
 }
}
</code></pre>

</code>

blocks|key|3128354|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3128355|的西班牙语版本如下：|blockquote|3128356|3128357|3128358|++++++++public+static+string+numeroALetras(int+number)
++++{
++++++++if+(number+==+0)
++++++++++++return+"cero";

++++++++if+(number+<+0)
++++++++++++return+"menos+"+%2B+numeroALetras(Math.Abs(number));

++++++++string+words+=+"";

++++++++if+((number+/+1000000)+>+0)
++++++++{
++++++++++++words+%2B=+numeroALetras(number+/+1000000)+%2B+"+millón+";
++++++++++++number+%25=+1000000;
++++++++}

++++++++if+((number+/+1000)+>+0)
++++++++{
++++++++++++words+%2B=+(number+/+1000)+==+1?+"mil+":+numeroALetras(number+/+1000)+%2B+"+mil+";
++++++++++++number+%25=+1000;
++++++++}
++++++++if+((number+/+100)+==+1)
++++++++{
++++++++++++if+(number+==+100)
++++++++++++++++words+%2B=+"cien";
++++++++++++else+words+%2B=+(number+/+100)>+1?+numeroALetras(number+/+100)+%2B+"+ciento+":"ciento+";
++++++++++++number+%25=+100;
++++++++}
++++++++if+((number+/+100)+>+1)
++++++++{
++++++++++++var+hundredMap+=+new[]+{"","",+"dosc",+"tresc",+"cuatroc",+"quin",+"seisc",+"sietec",+"ochoc",+"novec"+};
++++++++++++if+(number+>+199)
++++++++++++++++words+%2B=+hundredMap[number/100]+%2B+"ientos+";
++++++++++++else+{
++++++++++++++++words+%2B=+numeroALetras(number+/+100)+%2B+"+ientos+";
++++++++++++}
++++++++++++number+%25=+100;
++++++++}

++++++++if+(number+>+0)
++++++++{
++++++++++++if+(words+!=+"")
++++++++++++++++words+%2B=+"+";

++++++++++++var+unitsMap+=+new[]+{+"cero",+"uno",+"dos",+"tres",+"cuatro",+"cinco",+"seis",+"siete",+"ocho",+"nueve",+"diez",+"once",+"doce",+"trece",+"catorce",+"quince",+"dieciseis",+"diecisiete",+"dieciocho",+"diecinueve",+"veinte"+};
++++++++++++var+tensMap+=+new[]+{+"cero",+"diez",+"veinti",+"treinta",+"cuarenta",+"cincuenta",+"sesenta",+"setenta",+"ochenta",+"noventa"+};

++++++++++++if+(number+<+21)
++++++++++++++++words+%2B=+unitsMap[number];
++++++++++++else
++++++++++++{++++++++++++++++++++
++++++++++++++++words+%2B=+tensMap[number+/+10];
++++++++++++++++if+((number+%25+10)+>+0)
++++++++++++++++++++words+%2B=+((number+%25+10)>2?"+y+":+"")+%2B+unitsMap[number+%25+10];++++++++++++++++++++
++++++++++++}
++++++++}

++++++++return+words;
++++}|code-block|syntax|javascript|3128359|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|-4|4|5|6|M|7|@]|8|@]|9|$]]|$1|A|3|B|4|C|6|N|7|@]|8|@]|9|$]]|$1|D|3|-4|4|5|6|O|7|@]|8|@]|9|$]]|$1|E|3|-4|4|5|6|P|7|@]|8|@]|9|$]]|$1|F|3|G|4|H|6|Q|7|@]|8|@]|9|$I|J]]|$1|K|3|-4|4|5|6|R|7|@]|8|@]|9|$]]]|L|$]]

<blockquote>
 Here is the spanish version:
</blockquote>

<pre><code> public static string numeroALetras(int number)
 {
 if (number == 0)
 return "cero";

 if (number &lt; 0)
 return "menos " + numeroALetras(Math.Abs(number));

 string words = "";

 if ((number / 1000000) &gt; 0)
 {
 words += numeroALetras(number / 1000000) + " millón ";
 number %= 1000000;
 }

 if ((number / 1000) &gt; 0)
 {
 words += (number / 1000) == 1? "mil ": numeroALetras(number / 1000) + " mil ";
 number %= 1000;
 }
 if ((number / 100) == 1)
 {
 if (number == 100)
 words += "cien";
 else words += (number / 100)&gt; 1? numeroALetras(number / 100) + " ciento ":"ciento ";
 number %= 100;
 }
 if ((number / 100) &gt; 1)
 {
 var hundredMap = new[] {"","", "dosc", "tresc", "cuatroc", "quin", "seisc", "sietec", "ochoc", "novec" };
 if (number &gt; 199)
 words += hundredMap[number/100] + "ientos ";
 else {
 words += numeroALetras(number / 100) + " ientos ";
 }
 number %= 100;
 }

 if (number &gt; 0)
 {
 if (words != "")
 words += " ";

 var unitsMap = new[] { "cero", "uno", "dos", "tres", "cuatro", "cinco", "seis", "siete", "ocho", "nueve", "diez", "once", "doce", "trece", "catorce", "quince", "dieciseis", "diecisiete", "dieciocho", "diecinueve", "veinte" };
 var tensMap = new[] { "cero", "diez", "veinti", "treinta", "cuarenta", "cincuenta", "sesenta", "setenta", "ochenta", "noventa" };

 if (number &lt; 21)
 words += unitsMap[number];
 else
 { 
 words += tensMap[number / 10];
 if ((number % 10) &gt; 0)
 words += ((number % 10)&gt;2?" y ": "") + unitsMap[number % 10]; 
 }
 }

 return words;
 }
</code></pre>

blocks|key|347755|text|我实际上需要在我正在开发的一个应用程序中使用它，但对这里的任何解决方案都不满意。仅供参考，此解决方案利用了C#+7.0对本地函数的支持。我还使用了新的数字分隔符，使较大的数字更具可读性。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|347756|public+static+class+NumberExtensions
{
++++private+const+string+negativeWord+=+"negative";
++++private+static+readonly+Dictionary<ulong,+string>+_wordMap+=+new+Dictionary<ulong,+string>
++++{
++++++++[1_000_000_000_000_000_000]+=+"quintillion",
++++++++[1_000_000_000_000_000]+=+"quadrillion",
++++++++[1_000_000_000_000]+=+"trillion",
++++++++[1_000_000_000]+=+"billion",
++++++++[1_000_000]+=+"million",
++++++++[1_000]+=+"thousand",
++++++++[100]+=+"hundred",
++++++++[90]+=+"ninety",
++++++++[80]+=+"eighty",
++++++++[70]+=+"seventy",
++++++++[60]+=+"sixty",
++++++++[50]+=+"fifty",
++++++++[40]+=+"forty",
++++++++[30]+=+"thirty",
++++++++[20]+=+"twenty",
++++++++[19]+=+"nineteen",
++++++++[18]+=+"eighteen",
++++++++[17]+=+"seventeen",
++++++++[16]+=+"sixteen",
++++++++[15]+=+"fifteen",
++++++++[14]+=+"fourteen",
++++++++[13]+=+"thirteen",
++++++++[12]+=+"twelve",
++++++++[11]+=+"eleven",
++++++++[10]+=+"ten",
++++++++[9]+=+"nine",
++++++++[8]+=+"eight",
++++++++[7]+=+"seven",
++++++++[6]+=+"six",
++++++++[5]+=+"five",
++++++++[4]+=+"four",
++++++++[3]+=+"three",
++++++++[2]+=+"two",
++++++++[1]+=+"one",
++++++++[0]+=+"zero"
++++};

++++public+static+string+ToWords(this+short+num)
++++{
++++++++var+words+=+ToWords((ulong)Math.Abs(num));
++++++++return+num+<+0+?+$"{negativeWord}+{words}"+:+words;
++++}

++++public+static+string+ToWords(this+ushort+num)
++++{
++++++++return+ToWords((ulong)num);
++++}

++++public+static+string+ToWords(this+int+num)
++++{
++++++++var+words+=+ToWords((ulong)Math.Abs(num));
++++++++return+num+<+0+?+$"{negativeWord}+{words}"+:+words;
++++}

++++public+static+string+ToWords(this+uint+num)
++++{
++++++++return+ToWords((ulong)num);
++++}

++++public+static+string+ToWords(this+long+num)
++++{
++++++++var+words+=+ToWords((ulong)Math.Abs(num));
++++++++return+num+<+0+?+$"{negativeWord}+{words}"+:+words;
++++}

++++public+static+string+ToWords(this+ulong+num)
++++{
++++++++var+sb+=+new+StringBuilder();
++++++++var+delimiter+=+String.Empty;

++++++++void+AppendWords(ulong+dividend)
++++++++{
++++++++++++void+AppendDelimitedWord(ulong+key)
++++++++++++{
++++++++++++++++sb.Append(delimiter);
++++++++++++++++sb.Append(_wordMap[key]);
++++++++++++++++delimiter+=+20+<=+key+&&+key+<+100+?+"-"+:+"+";
++++++++++++}

++++++++++++if+(_wordMap.ContainsKey(dividend))
++++++++++++{
++++++++++++++++AppendDelimitedWord(dividend);
++++++++++++}
++++++++++++else
++++++++++++{
++++++++++++++++var+divisor+=+_wordMap.First(m+=>+m.Key+<=+dividend).Key;
++++++++++++++++var+quotient+=+dividend+/+divisor;
++++++++++++++++var+remainder+=+dividend+%25+divisor;

++++++++++++++++if+(quotient+>+0+&&+divisor+>=+100)
++++++++++++++++{
++++++++++++++++++++AppendWords(quotient);
++++++++++++++++}

++++++++++++++++AppendDelimitedWord(divisor);

++++++++++++++++if+(remainder+>+0)
++++++++++++++++{+++
++++++++++++++++++++AppendWords(remainder);
++++++++++++++++}
++++++++++++}
++++++++}

++++++++AppendWords(num);
++++++++return+sb.ToString();
++++}++++
}|code-block|syntax|javascript|347757|肉在最后一个ToWords重载中。|offset|length|style|CODE|347758|entityMap^0|0|0|6|7|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

I actually needed this for an app I'm working on, but wasn't happy with any of the solutions here. FYI, this solution takes advantage of C# 7.0's support for local functions. I also used the new digit separator to make the larger numbers more readable.

<pre><code>public static class NumberExtensions
{
 private const string negativeWord = "negative";
 private static readonly Dictionary&lt;ulong, string&gt; _wordMap = new Dictionary&lt;ulong, string&gt;
 {
 [1_000_000_000_000_000_000] = "quintillion",
 [1_000_000_000_000_000] = "quadrillion",
 [1_000_000_000_000] = "trillion",
 [1_000_000_000] = "billion",
 [1_000_000] = "million",
 [1_000] = "thousand",
 [100] = "hundred",
 [90] = "ninety",
 [80] = "eighty",
 [70] = "seventy",
 [60] = "sixty",
 [50] = "fifty",
 [40] = "forty",
 [30] = "thirty",
 [20] = "twenty",
 [19] = "nineteen",
 [18] = "eighteen",
 [17] = "seventeen",
 [16] = "sixteen",
 [15] = "fifteen",
 [14] = "fourteen",
 [13] = "thirteen",
 [12] = "twelve",
 [11] = "eleven",
 [10] = "ten",
 [9] = "nine",
 [8] = "eight",
 [7] = "seven",
 [6] = "six",
 [5] = "five",
 [4] = "four",
 [3] = "three",
 [2] = "two",
 [1] = "one",
 [0] = "zero"
 };

 public static string ToWords(this short num)
 {
 var words = ToWords((ulong)Math.Abs(num));
 return num &lt; 0 ? $"{negativeWord} {words}" : words;
 }

 public static string ToWords(this ushort num)
 {
 return ToWords((ulong)num);
 }

 public static string ToWords(this int num)
 {
 var words = ToWords((ulong)Math.Abs(num));
 return num &lt; 0 ? $"{negativeWord} {words}" : words;
 }

 public static string ToWords(this uint num)
 {
 return ToWords((ulong)num);
 }

 public static string ToWords(this long num)
 {
 var words = ToWords((ulong)Math.Abs(num));
 return num &lt; 0 ? $"{negativeWord} {words}" : words;
 }

 public static string ToWords(this ulong num)
 {
 var sb = new StringBuilder();
 var delimiter = String.Empty;

 void AppendWords(ulong dividend)
 {
 void AppendDelimitedWord(ulong key)
 {
 sb.Append(delimiter);
 sb.Append(_wordMap[key]);
 delimiter = 20 &lt;= key &amp;&amp; key &lt; 100 ? "-" : " ";
 }

 if (_wordMap.ContainsKey(dividend))
 {
 AppendDelimitedWord(dividend);
 }
 else
 {
 var divisor = _wordMap.First(m =&gt; m.Key &lt;= dividend).Key;
 var quotient = dividend / divisor;
 var remainder = dividend % divisor;

 if (quotient &gt; 0 &amp;&amp; divisor &gt;= 100)
 {
 AppendWords(quotient);
 }

 AppendDelimitedWord(divisor);

 if (remainder &gt; 0)
 { 
 AppendWords(remainder);
 }
 }
 }

 AppendWords(num);
 return sb.ToString();
 } 
}
</code></pre>

The meat is in the last <code>ToWords</code> overload.

blocks|key|347770|text|我的任务是创建一个WEB，使用C#将数字转换为单词。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|347771|可以是整数也可以是48小时内的小数点。|347772|调用将来自使用Ajax+Post方法的前端应用程序，并在网页中返回转换后的结果。|347773|我在GitHub中公开分享了这个项目以供参考：https://github.com/marvinglennlacuna/NumbersToWordsConverter.Api|offset|length|347774|放置了以下技术实现：|347775|使用Controller|347776|Service|unordered-list-item|347777|
|347778|Model|347779|347780|Error+Handling|347781|347782|Unit+|347783|347784|代码覆盖率进行|347785|MVC结构化|ordered-list-item|347786|API测试-+98%25|347787|Jquery|347788|347789|347790|以及关于以下内容的技术文档：|347791|347792|Purpose|347793|Prerequisites|347794|Functionl+Requirements|347795|Process图和输出|347796|347797|**网页结果(US-001)+**|347798|347799|+US-001通过网页处理将数字转换为文字|blockquote|347800|347801|347802|​|347803|📷|atomic|347804|347805|347806|+US-001通过网页输出将数字转换为单词|347807|347808|347809|347810|347811|347812|通过邮递员(US-002)获得的结果|style|BOLD|347813|347814|+US-002+-通过邮递过程将数字转换为单词|347815|347816|347817|347818|347819|347820|347821|+US-002+-通过邮递员输出将数字转换为单词|347822|347823|347824|347825|347826|347827|我认为，如果你在面试/代码测试/学校中需要它作为参考，或者只是为了好玩，那么分享一个有效的解决方案是值得的。|347828|干杯，马文|347829|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/marvinglennlacuna/NumbersToWordsConverter.Api|1|IMAGE|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/70ba31101556c934de9b0b80e2cad0cc.jpeg|imageAlt|2|https://ask.qcloudimg.com/http-save/yehe-900000/34d5554f3bc23d2bd8155caff1338396.png|3|https://ask.qcloudimg.com/http-save/yehe-900000/f11d33dbf93520c9c433365fd24fa566.jpeg|4|https://ask.qcloudimg.com/http-save/yehe-900000/b84a932100b76bb1d759f38d9a364ad6.png^0|0|0|0|N|1S|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|1|1|0|0|0|0|0|0|0|0|1|2|0|0|G|2|0|0|0|N|0|0|0|0|1|0|0|1|0|1|3|0|0|1|0|0|0|O|0|0|0|0|1|0|0|1|0|1|4|0|0|1|0|0|1I|0|0|5|0^^$0|@$1|2|3|4|5|6|7|3I|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|3J|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|3K|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|3L|8|@]|9|@$H|3M|I|3N|1|3O]]|A|$]]|$1|J|3|K|5|6|7|3P|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|3Q|8|@]|9|@]|A|$]]|$1|N|3|O|5|P|7|3R|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|3S|8|@]|9|@]|A|$]]|$1|S|3|T|5|P|7|3T|8|@]|9|@]|A|$]]|$1|U|3|R|5|6|7|3U|8|@]|9|@]|A|$]]|$1|V|3|W|5|P|7|3V|8|@]|9|@]|A|$]]|$1|X|3|R|5|6|7|3W|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|P|7|3X|8|@]|9|@]|A|$]]|$1|10|3|R|5|6|7|3Y|8|@]|9|@]|A|$]]|$1|11|3|12|5|P|7|3Z|8|@]|9|@]|A|$]]|$1|13|3|14|5|15|7|40|8|@]|9|@]|A|$]]|$1|16|3|17|5|15|7|41|8|@]|9|@]|A|$]]|$1|18|3|19|5|15|7|42|8|@]|9|@]|A|$]]|$1|1A|3|-4|5|6|7|43|8|@]|9|@]|A|$]]|$1|1B|3|-4|5|6|7|44|8|@]|9|@]|A|$]]|$1|1C|3|1D|5|6|7|45|8|@]|9|@]|A|$]]|$1|1E|3|-4|5|6|7|46|8|@]|9|@]|A|$]]|$1|1F|3|1G|5|15|7|47|8|@]|9|@]|A|$]]|$1|1H|3|1I|5|15|7|48|8|@]|9|@]|A|$]]|$1|1J|3|1K|5|15|7|49|8|@]|9|@]|A|$]]|$1|1L|3|1M|5|15|7|4A|8|@]|9|@]|A|$]]|$1|1N|3|-4|5|6|7|4B|8|@]|9|@]|A|$]]|$1|1O|3|1P|5|6|7|4C|8|@]|9|@]|A|$]]|$1|1Q|3|-4|5|6|7|4D|8|@]|9|@]|A|$]]|$1|1R|3|1S|5|1T|7|4E|8|@]|9|@]|A|$]]|$1|1U|3|-4|5|6|7|4F|8|@]|9|@]|A|$]]|$1|1V|3|-4|5|6|7|4G|8|@]|9|@]|A|$]]|$1|1W|3|1X|5|6|7|4H|8|@]|9|@]|A|$]]|$1|1Y|3|1Z|5|20|7|4I|8|@]|9|@$H|4J|I|4K|1|4L]]|A|$]]|$1|21|3|1X|5|6|7|4M|8|@]|9|@]|A|$]]|$1|22|3|-4|5|6|7|4N|8|@]|9|@]|A|$]]|$1|23|3|24|5|1T|7|4O|8|@]|9|@]|A|$]]|$1|25|3|-4|5|6|7|4P|8|@]|9|@]|A|$]]|$1|26|3|-4|5|6|7|4Q|8|@]|9|@]|A|$]]|$1|27|3|1X|5|6|7|4R|8|@]|9|@]|A|$]]|$1|28|3|1Z|5|20|7|4S|8|@]|9|@$H|4T|I|4U|1|4V]]|A|$]]|$1|29|3|1X|5|6|7|4W|8|@]|9|@]|A|$]]|$1|2A|3|2B|5|6|7|4X|8|@$H|4Y|I|4Z|2C|2D]]|9|@]|A|$]]|$1|2E|3|-4|5|6|7|50|8|@]|9|@]|A|$]]|$1|2F|3|2G|5|1T|7|51|8|@$H|52|I|53|2C|2D]]|9|@]|A|$]]|$1|2H|3|-4|5|6|7|54|8|@]|9|@]|A|$]]|$1|2I|3|-4|5|6|7|55|8|@]|9|@]|A|$]]|$1|2J|3|1X|5|6|7|56|8|@$H|57|I|58|2C|2D]]|9|@]|A|$]]|$1|2K|3|1Z|5|20|7|59|8|@$H|5A|I|5B|2C|2D]]|9|@$H|5C|I|5D|1|5E]]|A|$]]|$1|2L|3|1X|5|6|7|5F|8|@$H|5G|I|5H|2C|2D]]|9|@]|A|$]]|$1|2M|3|-4|5|6|7|5I|8|@]|9|@]|A|$]]|$1|2N|3|2O|5|1T|7|5J|8|@$H|5K|I|5L|2C|2D]]|9|@]|A|$]]|$1|2P|3|-4|5|6|7|5M|8|@]|9|@]|A|$]]|$1|2Q|3|-4|5|6|7|5N|8|@]|9|@]|A|$]]|$1|2R|3|1X|5|6|7|5O|8|@$H|5P|I|5Q|2C|2D]]|9|@]|A|$]]|$1|2S|3|1Z|5|20|7|5R|8|@$H|5S|I|5T|2C|2D]]|9|@$H|5U|I|5V|1|5W]]|A|$]]|$1|2T|3|1X|5|6|7|5X|8|@$H|5Y|I|5Z|2C|2D]]|9|@]|A|$]]|$1|2U|3|2V|5|6|7|60|8|@$H|61|I|62|2C|2D]]|9|@]|A|$]]|$1|2W|3|2X|5|6|7|63|8|@$H|64|I|65|2C|2D]]|9|@]|A|$]]|$1|2Y|3|-4|5|6|7|66|8|@]|9|@]|A|$]]]|2Z|$30|$5|31|32|33|A|$34|35]]|36|$5|37|32|38|A|$39|3A|3B|-4]]|3C|$5|37|32|38|A|$39|3D|3B|-4]]|3E|$5|37|32|38|A|$39|3F|3B|-4]]|3G|$5|37|32|38|A|$39|3H|3B|-4]]]]

I was tasked to create a WEB API that converts numbers to words using C#. 

Can be whole number or with decimal points in 48 hours time. 

The call will be coming from a front-end application using Ajax Post method and return the converted result in the webpage. 

I've publicly shared that project in the GitHub for reference: <a href="https://github.com/marvinglennlacuna/NumbersToWordsConverter.Api" rel="nofollow noreferrer">https://github.com/marvinglennlacuna/NumbersToWordsConverter.Api</a>

With the following technical implementatation in placed: 

<ol>
<li>MVC structured</li>
<li>API Controller</li>
<li>Service</li>
<li>Model</li>
<li>Error Handling</li>
<li>Unit Testing using MSTest</li>
<li>Code Coverage - 98%</li>
<li>Jquery</li>
</ol>

And with technical documentation about the following as well:

<ol>
<li>Purpose</li>
<li>Prerequisites</li>
<li>Functionl Requirements</li>
<li>Process Diagram and Output</li>
</ol>

**Result via Web Page (US-001) **

<blockquote>
 US-001 Convert Numbers to Words via web page process
</blockquote>

<a href="https://i.stack.imgur.com/igoc9.jpg" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/igoc9.jpg" alt="enter image description here"></a>

<blockquote>
 US-001 Convert Numbers to Words via web page output
</blockquote>

<a href="https://i.stack.imgur.com/dyhjC.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/dyhjC.png" alt="enter image description here"></a>

Result via Postman (US-002)

<blockquote>
 US-002 - Convert Numbers to Words via Postman process
</blockquote>

<a href="https://i.stack.imgur.com/Hle97.jpg" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/Hle97.jpg" alt="enter image description here"></a>

<blockquote>
 US-002 - Convert Numbers to Words via Postman output
</blockquote>

<a href="https://i.stack.imgur.com/UutQH.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/UutQH.png" alt="enter image description here"></a>

I think it's just worth sharing a working solution in the case you need it for reference in interview/code test/school or for fun only. 

Cheers, 
Marvin

Is there a library or a class/function that I can use to convert an integer to it's verbal representation?

Example input:

<blockquote>
 4,567,788`
</blockquote>

Example output:

<blockquote>
 Four million, Five hundred sixty-seven thousand, seven hundred eighty-eight
</blockquote>

How can I convert an integer into its verbal representation?

GitHub

有没有一个库或类/函数可以用来将一个整数转换成它的语言表示？示例输入： 4,567,788`输出示例：四百万、56.7万、788

问我如何将一个整数转换成它的口头表示？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问我如何将一个整数转换成它的口头表示？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问我如何将一个整数转换成它的口头表示？
EN