Selection.NumberFormatLocal = "[DBNum2][$-804]G/通用格式"

------解决方案--------------------
用最笨的方法能做啊 转换字符

------解决方案--------------------
C# code
    public string GetMoney(double dd)
    {
        string s = dd.ToString("#L#E#D#C#K#E#D#C#J#E#D#C#I#E#D#C#H#E#D#C#G#E#D#C#F#E#D#C#.0B0A");
        string d = Regex.Replace(s, @"((?<=-|^)[^1-9]*)|((?'z'0)[0A-E]*((?=[1-9])|(?'-z'(?=[F-L\.]|$))))|((?'b'[F-L])(?'z'0)[0A-L]*((?=[1-9])|(?'-z'(?=[\.]|$))))", "${b}${z}");
        string value = Regex.Replace(d, ".", delegate(Match m)
        { return "负元空零壹贰叁肆伍陆柒捌玖空空空空空空空分角拾佰仟萬億兆京垓秭穰"[m.Value[0] - '-'].ToString(); });
        return value;
    }
Response.Write(GetMoney(123456789));
//壹億贰仟叁佰肆拾伍萬陆仟柒佰捌拾玖元

------解决方案--------------------
循环除10取余吧，做进制转换的思路~

------解决方案--------------------
探讨

循环除10取余吧，做进制转换的思路~


------解决方案--------------------
四个位四个位判断，如果不满四位不加大单位（如亿，万），大于四位数开始加万，加亿

------解决方案--------------------
自己写的java代码，不过还有一点问题，大家可以运行一下，注意包的问题。

Java code

package edu.xawl.daocao;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class ChangeUpDown
{
    public static void main(String[] args) throws IOException
    {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringBuffer rs = new StringBuffer();
        System.out.println("input a integer:");
        while (true)
        {
            String str = br.readLine();
            if ("bye".equals(str))
                break;
            if (str.length() > 12)
            {
                System.out.println("数字过大，请重新输入");
                continue;
            }
            rs = OK(str);
            System.out.println(rs);
        }

    }

    static StringBuffer OK(String str)
    {
        // 传过来的参数
        String diag = str;
        // sb要来存储转换出来的值
        StringBuffer sb = new StringBuffer();
        // 堆栈
        MyStack ms = new MyStack();
        // 用来判断是否加零，比如"100001111"，中间有4个零，就判断不加零，并且不写"万"。
        int temp = 0;
        // 这个不用说额吧
        String[] hanYuDiag = { "", "十", "百", "千", "万", "亿" };

        /**
         * 数字入栈
         */
        for (int i = diag.length() - 1; i >= 0; i--)
        {
            ms.push(diag.charAt(i) - 48);
        }

        /**
         * 数子出栈，并操作
         */
        for (int i = ms.getTopAdd(); i >= 0; i--)
        {
            // 出来一个数字
            //11 10 10 9 9 8 
            int newDiag = ms.pop();
            // 由于是栈，所以从高位出来，最先出来的是最高位的，所以，由于只做到"亿"，所以只能有12位，这里是数组，所以下表最大为11
            if (i >= 8 && i <= 11)
            {
                // 当这个位不为零的时候，老老实实的把你显示出来吧，数字本身转化出来的值连接上它自己的权值
                if (newDiag != 0)
                {
                    sb.append(ChangeUpDown.changeUp(newDiag) + hanYuDiag[i - 8]);
                } else
                {
                    // 当这个位等于零的时候，就要分情况讨论了，由于我们知道，如果是0万的话，我们不能显示出来0万。所以...
                    // 判断，在位数在亿位以上时，判断它的下一位是不是零，要是零的话，就结束该层循环，不是零的话
                    // 往下走
                    if (i > 8 && ms.top() == 0)
                    {
                        temp++;
                        continue;
                    }
                    // temp要清空，你了解的.
                    if (i == 8 && temp == 3)
                    {
                        temp = 0;
                        continue;
                    }
                    // 显示零
                    sb.append(ChangeUpDown.changeUp(newDiag));
                }
                // 这里了，当到"亿"位的时候要判断写不写"亿"
                if (i == 8 && temp != 3)
                {
                    temp = 0;
                    sb.append(hanYuDiag[5]);
                }
            }
            if (i >= 4 && i <= 7)
            {
                if (newDiag != 0)
                {
                    sb.append(ChangeUpDown.changeUp(newDiag) + hanYuDiag[i - 4]);
                } else
                {
                    if (i > 4 && ms.top() == 0)
                    {
                        temp++;
                        continue;
                    }
                    if (i == 4 && temp == 3)
                    {
                        temp = 0;
                        continue;
                    }
                    sb.append(ChangeUpDown.changeUp(newDiag));
                }
                if (i == 4 && temp != 3)
                {
                    temp = 0;
                    sb.append(hanYuDiag[4]);
                }
            }
            if (i <= 3)
            {
                if (newDiag != 0)
                {
                    sb.append(ChangeUpDown.changeUp(newDiag) + hanYuDiag[i]);
                } else
                {
                    if (i > 0 && ms.top() == 0)
                    {
                        continue;
                    }
                    if (i == 0)
                    {
                        continue;
                    }
                    sb.append(ChangeUpDown.changeUp(newDiag));
                }
            }
        }
        return sb;
    }

    static String changeUp(int n)
    {
        String upStr = null;
        switch (n)
        {
            case 1:
                upStr = "壹";
                break;
            case 2:
                upStr = "贰";
                break;
            case 3:
                upStr = "叁";
                break;
            case 4:
                upStr = "肆";
                break;
            case 5:
                upStr = "伍";
                break;
            case 6:
                upStr = "陆";
                break;
            case 7:
                upStr = "柒";
                break;
            case 8:
                upStr = "捌";
                break;
            case 9:
                upStr = "玖";
                break;
            case 0:
                upStr = "零";
                break;
            default:
                System.out.println("系统错误！");

        }
        return upStr;
    }

}

class MyStack
{
    private int[] arr = new int[20];
    private int index = -1;
    private int top = 0;

    public int getTopAdd()
    {
        return top;
    }

    public void push(int n)
    {
        index++;
        arr[index] = n;
        top = index;
    }

    public int pop()
    {
        int n = arr[index];
        index--;
        top = index;
        return n;
    }

    public int top()
    {
        // 在这儿应该要加判断是否有元素????
        int n = arr[index];
        return n;
    }
}