2012给大家拜年了,恭迎佛诞,散分发布代码

Question

首先给论坛全体拜年了拜年了祝六亲眷属皆安乐肚大能容笑口常开!!!
-------------------------------------------------------------
发布代码前先声明:
1\这个代码在测试完成后就没时间去优化,如果有心人可以对代码进行优化,或转换认为更好的代码写法,这里发布仅提供参考,当然这些代码运行及运算都是正确的,因为有不同算法的双向运算可以相互印证是否运算正确,比较有信心,写好这个后老有一个想法:这个运算可以作为标准来校验其他写法运算是否正确.那么,对还是不对,有待大家测试及评论,谢谢!2\代码写法比较随意,可以用其他写法替代,如果看不惯自己改去.3\代码发布主要的转换部分,还要说明一点,这时我学C#WINFOMR编写仅不到3个月的代码和写法,别追问代码的意思是什么,喜欢自己动手调试和动脑的人,如果发现代码发布遗漏可以补充.using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
namespace WindowsFormsApplication2
{
    public partial class Form1 : Form
    {
        string Zz = "零壹贰叁肆伍陆柒捌玖", Bj = "0123456789"; Double SsWr = new double(); bool PanDuan = true;
        string[] Jz = { "元", "拾", "佰", "仟" };
        string[] Jzs = { "拾", "佰", "仟" };
        string[] Zs = { "万", "亿", "兆", "京", "垓", "秭", "穰", "沟", "涧", "正", "载", "极", "恒河沙", "阿僧祇", "那由他", "不可思议", "☆无量", "☆不可说☆" };
        string[] Xs = { "角", "分", "厘","毫","丝","忽","微","纤","沙","尘","埃","渺","莫", "模糊", "逡巡","须臾","瞬息","弹指","刹那","六德","空虚","☆清静" };        public Form1()
        {
            InitializeComponent();
        }
private void Form1_Load(object sender, EventArgs e)
        {
            ToolTip KjTs = new ToolTip();
            KjTs.SetToolTip(ZhuanHuang, "单击执行转换");
            KjTs.SetToolTip(XuanXiang, "请选择要执行小数的“四舍五入”位数");
            KjTs.SetToolTip(Kuo, "选择该项时将强行扩展整数的位数到万无量=[不可说]，没有实际意义。");
        }
private void ZhuanHuang_Click(object sender, EventArgs e)
        {
            string DD_BM = SuZi.Text.Trim(); string[] Fg = new string[2];            try
            {
                if (SuZi.Text.Length > 99 || SuZi.Text == "")
                {
                    if (SuZi.Text.Length > 99)
                        MessageBox.Show("1、操作非法,输入数值超过范围，无法计算！请重新输入小等于69位整数(强制扩展：小等于76位)和小等于22位小数！", "友情提示！", MessageBoxButtons.OK, MessageBoxIcon.Information);
                    if (SuZi.Text == "")
                        MessageBox.Show("2、操作非法！请重新输入小等于69位整数(强制扩展：小等于76位)和小等于22位小数！", "友情提示！", MessageBoxButtons.OK, MessageBoxIcon.Information);
                }
                else
                {
                    string GuoLvZiFu = DD_BM;
                    ZongWenSuZhi.Text = ""; SsWr = 0;
                    do { GuoLvZiFu = 过滤(GuoLvZiFu, false); }
                    while (PanDuan == false);//再循环
                    DD_BM = GuoLvZiFu;
                    if (ZzS.Checked)
                    {
                        do { GuoLvZiFu = 过滤(GuoLvZiFu, true); }
                        while (PanDuan == false);//再循环
                        DD_BM = GuoLvZiFu;
                        if (DD_BM.IndexOf("元") >= 0) { Fg = DD_BM.Split('元'); } //整数
                        else { Fg[0] = ""; Fg[1] = DD_BM; }//纯小数
                    }
                    if (SzZ.Checked) Fg = DD_BM.Split('.');                    if (ZzS.Checked)//中文→数字
                    {
                        if (Fg[0] != "") //整数部分
                        {
                            if (Zhuan.Checked) ZongWenSuZhi.Text = Zh_Zwz(ZzZhengShu(Fg[0]), "中文→数字整数", true);
                            if (!Zhuan.Checked) ZongWenSuZhi.Text = ZzZhengShu(Fg[0]);
                        }
                        if (Fg.Length == 2 && Fg[1] != "") //小数部分
                        {
                            if (Zhuan.Checked) ZongWenSuZhi.Text += Zh_Zwz(XiaoShu(Fg[1], ZzS.Checked), "中文→数字小数", true);
                            if (!Zhuan.Checked) ZongWenSuZhi.Text += XiaoShu(Fg[1], ZzS.Checked);
                        }
                    }                    if (SzZ.Checked)//数字→中文
                    {
                        if (!Kuo.Checked)//不扩展
                        {
                            if (Fg[0].Length <= 69) ZhRk(Fg);
                            else MessageBox.Show("3、操作非法，请重新输入小于69位整数和小于22位小数，如果大于以上整数部分需要转换请选择[强制扩展]，友情提醒[强制扩展]是无意义的数字，故曰：不可说！", "友情提示！", MessageBoxButtons.OK, MessageBoxIcon.Information);
                        }                        if (Kuo.Checked)//扩展
                        {
                            if (Fg[0].Length <= 76) ZhRk(Fg);
                            else MessageBox.Show("4、操作非法，请重新输入[强制扩展]小于76位整数和小于22位小数！", "友情提示！", MessageBoxButtons.OK, MessageBoxIcon.Information);
                        }
                    }
                }
            }
            catch (Exception)
            { }
        }        private void ZhRk(string[] Fg)//数字-中文转换入口
        {
            try
            {
                if (!Zhuan.Checked) ZongWenSuZhi.Text = Zh_Zwz(Fg[0], "数字→中文整数", false);
                if (Zhuan.Checked) ZongWenSuZhi.Text = TiHuan(Zh_Zwz(Fg[0], "数字→中文整数", false));
                if (Fg.Length == 1) ZongWenSuZhi.Text = ZongWenSuZhi.Text + "整";                if (Fg.Length == 2 && Fg[1] != "")//小数
                {
                    if (Fg[1].Length > 22) { Fg[1] = Fg[1].Substring(0, 22); MessageBox.Show("6、操作非法，请重新输入小等于22位小数，大于22位时将截取自左开始到22位的数字，22位后面的数字不被列入转换范围！", "友情提示！", MessageBoxButtons.OK, MessageBoxIcon.Information); }//截取位数                    if (XuanXiang.Text != "四舍五入") Fg[1] = SheRu(Fg[1], "五入");
                    if (SiLiu.Text != "四舍六入") Fg[1] = SheRu(Fg[1], "六入");                    if (!Zhuan.Checked) ZongWenSuZhi.Text += Zh_Zwz(Fg[1], "数字→中文小数", false);
                    if (Zhuan.Checked) ZongWenSuZhi.Text += TiHuan(Zh_Zwz(Fg[1], "数字→中文小数", false));
                }
            }
            catch (Exception)
            {  }
        }        private string Zh_Zwz(string DD_BM, string BiaoJi, bool Zs)//[等效]转换中文/数值
        {
            string Sz = "";
            try
            {
                for (int Qs = 0; Qs < DD_BM.Length; Qs++)
                {
                    string Zf = DD_BM.Substring(Qs, 1);//依循环取其中一个字符
                    if (Bj.IndexOf(Zf) >= 0 && !Zs)//比较
                    { Sz += Zz.Substring(Bj.IndexOf(Zf), 1); } //等效中文
                    if (Zz.IndexOf(Zf) >= 0 && Zs)
                    { Sz += Bj.Substring(Zz.IndexOf(Zf), 1); }//等效数字
                }
                if (BiaoJi == "中文→数字小数") Sz = "." + Sz;//补
                if (BiaoJi == "数字→中文小数") Sz = XiaoShu(Sz, false);
                if (BiaoJi == "数字→中文整数") Sz = SzZhengShu(Sz);
            }
            catch (Exception)
            {  }
            return Sz;
        }        private string ZzZhengShu(string ZsBf)//中文→数字整数部分
        {
            string ZsB = ZsBf + "元";            try
            {
                do { ZsB = BuWei(ZsB); }
                while (PanDuan == false);//再循环
            }
            catch (Exception e)
            {  }
            finally { }
                
            return ZsB;
        }        private string 过滤(string GuoLv, bool Gv)
        {
            string ZhongWen = "", Bij = "", SzHc = "";            try
            {
                if (Gv)//中文→数字过滤数字小数点
                {
                    for (int Gl = GuoLv.Length - 1; Gl >= 0; Gl--)
                    {
                        Bij = GuoLv.Substring(Gl, 1);
                        if (("." + Bj).IndexOf(Bij) >= 0)
                        { GuoLv = GuoLv.Replace(Bij, ""); PanDuan = false; break; }
                        else { PanDuan = true; }
                    }
                }
                if (!Gv) //消除所有以外的字符
                {
                    for (int Hcf = 0; Hcf < Jz.Length; Hcf++)
                    { SzHc += Jz[Hcf]; }
                    for (int Hcf = 0; Hcf < Zs.Length; Hcf++)
                    { SzHc += Zs[Hcf]; }
                    for (int Hcf = 0; Hcf < Xs.Length; Hcf++)
                    { SzHc += Xs[Hcf]; }
                    SzHc += "." + Zz + Bj;
                    for (int Gg = 0; Gg < GuoLv.Length; Gg++)
                    {
                        Bij = GuoLv.Substring(Gg, 1);
                        if (SzHc.IndexOf(Bij) < 0)
                        { GuoLv = GuoLv.Replace(Bij, ""); PanDuan = false; break; }
                        else { PanDuan = true; }
                    }
                }
            }
            catch (Exception)
            {  }
            return ZhongWen = GuoLv;
        }        
    }
}

Answer 1

接上面的,因为发布字符超过了.private string BuWei(string ZsBf)//补位
        {
            string ZsB = "", Hc = "零仟零佰零拾零☆不可说☆零仟零佰零拾零☆无量零仟零佰零拾零不可思议零仟零佰零拾零那由他零仟零佰零拾零阿僧祇零仟零佰零拾零恒河沙零仟零佰零拾零极零仟零佰零拾零载零仟零佰零拾零正零仟零佰零拾零涧零仟零佰零拾零沟零仟零佰零拾零穰零仟零佰零拾零秭零仟零佰零拾零垓零仟零佰零拾零京零仟零佰零拾零兆零仟零佰零拾零亿零仟零佰零拾零万零仟零佰零拾零元",
                   YuanW = "", Bij = "", Zz = "壹贰叁肆伍陆柒捌玖";
            try
            {
                for (int JcJz = 0; JcJz < ZsBf.Length; JcJz++)
                {
                    Bij = ZsBf.Substring(ZsBf.Length - (JcJz + 1), 1);//从尾部读
                    YuanW = Hc.Substring(Hc.Length - (JcJz + 1), 1);                    if (Bij == YuanW)
                    { if (ZsB != "") { ZsB = ZsB.Insert(0, Bij); } else { ZsB = Bij; } PanDuan = true; }
                    else//检查对应位置
                    {
                        if (Hc.IndexOf(Bij) == -1 && YuanW == "零" && Zz.IndexOf(Bij) >= 0)//壹-玖的处理
                        { ZsB = ZsB.Insert(0, Bij); PanDuan = true; }
                        else
                        { ZsB = ZsBf.Insert((ZsBf.Length - (JcJz + 1)) + 1, YuanW); PanDuan = false; break; }
                    }
                    
                }
                if (PanDuan)
                {
                    for (int Qdw = 0; Qdw < Zs.Length; Qdw++)
                    { ZsB = ZsB.Replace(Zs[Qdw], ""); if (Qdw <= 3) { ZsB = ZsB.Replace(Jz[Qdw], ""); } }
                }
            }
            catch (Exception e)
            {  }
            finally { }            return ZsB;
        }        private string SzZhengShu(string ZsBf)//数字→中文整数部分
        {
            string ZsB = ""; int Ws = ZsBf.Length, Jw = 0, Cs = 0;            try
            {
                for (int Qs = 0; Qs < Ws; Qs++)
                {
                    Cs++;                    string Cr = "", Dx = ZsBf.Substring(Ws - (Qs + 1), 1);//倒序读取1个字符                    if (Cs < 5 && Jw == 0)
                    { Cr = Dx.Insert(1, Jz[Cs - 1]); }//插入万以内
                    else if (Cs < 4 && Jw > 0)
                    { Cr = Dx.Insert(1, Jzs[Cs - 1]); }//插入万以后
                    else
                    { Cr = Dx.Insert(1, Zs[Jw]); Jw++; Cs = 0; } //进位                    if (ZsB == "") ZsB = Cr; else ZsB = ZsB.Insert(0, Cr);//顺序合成
                }
            }
            catch (Exception e)
            {  }
            
            return ZsB;
        }        private string 小数补位(string 数值)
        {
            string 转换值 = "", 小数模板 = "", 小数模板2 = "糊巡臾息指那德虚清静", 取数值 = "", 取对照 = "";
            
            try
            {
                if (数值.IndexOf("☆") >= 0)
                { 转换值 = 数值.Substring(0, 数值.IndexOf("☆")); MessageBox.Show("16、操作非法，[☆清静]不被列入转换范围！", "友情提示！", MessageBoxButtons.OK, MessageBoxIcon.Information); }
                else { 转换值 = 数值; }
                for (int Sz = 0; Sz < Xs.Length; Sz++)
                { 小数模板 += "零" + Xs[Sz]; }
                for (int 位检 = 0; 位检 < 数值.Length; 位检++)
                {
                    取数值 = 转换值.Substring(位检, 1); 取对照 = 小数模板.Substring(位检, 1);
                    if (取数值 != 取对照)
                    {
                        if (取对照 == "零")
                        {
                            if (Zz.IndexOf(取数值) >= 0) { PanDuan = true; }//零-玖
                            else 
                            {
                                if (小数模板2.IndexOf(取对照) >= 0)
                                { 转换值 = 转换值.Insert(位检, 取对照); PanDuan = false; break; }//2-3字单位时后位不需补零
                                else 
                                { 转换值 = 转换值.Insert(位检 - 1, "零" + 取对照); PanDuan = false; break; }
                            }
                        }
                        else
                        {
                            if (小数模板2.IndexOf(取对照) >= 0)
                            { 转换值 = 转换值.Insert(位检, 取对照); PanDuan = false; break; }
                            else 
                            { 转换值 = 转换值.Insert(位检 - 1, "零" + 取对照); PanDuan = false; break; }
                        }
                    }
                    else 
                    { PanDuan = true; }
                }
            }
            catch (Exception e)
            {  }
            finally { }
            return 转换值;
        }        private string XiaoShu(string XsBf, bool Zs)//小数部分
        {
            string XsB = "";
            try
            {
                if (Zs)//还原中文大写不带单位
                {
                    XsB = XsBf.Replace("零", "");
                    do { XsB = 小数补位(XsB); }
                    while (PanDuan == false);//再循环
                    for (int Sz = 0; Sz < Xs.Length; Sz++)
                    { if (XsB.IndexOf(Xs[Sz]) >= 0) { XsB = XsB.Replace(Xs[Sz], ""); } }
                }
                if (!Zs)//合成中文大写带单位
                {
                    for (int Qs = 0; Qs < XsBf.Length; Qs++)
                    { XsB += XsBf.Substring(Qs, 1).Insert(1, Xs[Qs]); }
                }
            }
            catch (Exception)
            {  }
            
            return XsB;
        }        private string TiHuan(string Ling)//数字→中文整数去零补零, 
        {
            string Th = "", Lin = "零", Yuan = "元", Zl = Ling;
            string[] Tl = { "拾", "佰", "仟", "角", "分", "厘","毫","丝","忽","微","纤","沙","尘","埃","渺","莫",
                            "模糊", "逡巡","须臾","瞬息","弹指","刹那","六德","空虚","☆清静" };
            try
            {
                for (int Tli = 0; Tli < Tl.Length; Tli++)//替零
                {
                    if (Zl.IndexOf(Lin + Tl[Tli]) >= 0) Zl = Zl.Replace(Lin + Tl[Tli], Lin);
                    else Th = Zl;
                }                for (int Tll = 0; Tll < Th.Length; Tll++)//替零零必须循环
                { if (Th.IndexOf(Lin + Lin) >= 0) Th = Th.Replace(Lin + Lin, Lin); }                for (int Tlz = 0; Tlz < Zs.Length; Tlz++)//替零整 break;
                {
                    if (Th.IndexOf(Lin + Zs[Tlz]) >= 0) Th = Th.Replace(Lin + Zs[Tlz], Zs[Tlz]);
                    for (int Tzz = 0; Tzz < Zs.Length; Tzz++)//替整整
                    { if (Th.IndexOf(Zs[Tzz] + Zs[Tlz]) >= 0) Th = Th.Replace(Zs[Tzz] + Zs[Tlz], Zs[Tzz] + Lin); }
                }                for (int Tll = 0; Tll < Th.Length; Tll++)//替零零这里可以不用循环为了确保
                { if (Th.IndexOf(Lin + Lin) >= 0) Th = Th.Replace(Lin + Lin, Lin); }                if (Th.IndexOf(Lin + Yuan) >= 0) Th = Th.Replace(Lin + Yuan, Yuan);//零元                for (int Bks = 0; Bks < Zz.Length; Bks++)//限制到[0-9清净]不加数量
                { Th = Th.Replace(Zz.Substring(Bks, 1) + Tl[24], Tl[24]); }                if (Ling != "")//替换小数输入0.的处理。
                {
                    if (Th.Substring(0, 1) == Yuan) Th = Th.Replace(Yuan, "");
                    if (Th != "" && ZongWenSuZhi.Text == "")//有整数
                        if (Th.Substring(0, 1) == Lin) Th = Th.Substring(1, Th.Length - 1);
                }
            }
            catch (Exception)
            {  }
            
            return Th;
        }        private int JinDu(string XiaoShu)//精度
        {
            int Qw = 0;
            switch (XiaoShu)
            {
                case "一位精度": Qw = 1; break;
                case "二位精度": Qw = 2; break;
                case "三位精度": Qw = 3; break;
                case "四位精度": Qw = 4; break;
                case "五位精度": Qw = 5; break;
                case "六位精度": Qw = 6; break;
                case "七位精度": Qw = 7; break;
                case "八位精度": Qw = 8; break;
                case "九位精度": Qw = 9; break;
                case "十位精度": Qw = 10; break;
                case "十一精度": Qw = 11; break;
                case "十二精度": Qw = 12; break;
                case "十三精度": Qw = 13; break;
                case "十四精度": Qw = 14; break;
                case "十五精度": Qw = 15; break;
                case "十六精度": Qw = 16; break;
                case "十七精度": Qw = 17; break;
                case "十八精度": Qw = 18; break;
                case "十九精度": Qw = 19; break;
                case "二十精度": Qw = 20; break;
            }
            
            return Qw;
        }        private string SheRu(string Zf, string Xz)//舍入
        {
            string Sc = "",Sr=""; string[] Fg = new string[2];            try
            {
                int Qw = 0, Tw = 0;
                if (Xz == "五入") Qw = JinDu(XuanXiang.Text);
                if (Xz == "六入") Qw = JinDu(SiLiu.Text);
                if (Qw > 10 && Zf.Length > 10)
                { Fg[0] = Zf.Substring(0, 8); Fg[1] = Zf.Substring(8, (Zf.Length - 8)); }
                if (Fg[0] != null && Fg[1] != null) { Sr = Fg[1]; Tw = Qw - 8; } else { Sr = Zf; Tw = Qw; }
                SsWr = Convert.ToDouble("." + Sr);
                if (Xz == "五入")
                    Sc = Math.Round((decimal)SsWr, Tw, MidpointRounding.AwayFromZero).ToString();
                if (Xz == "六入")
                    Sc = Math.Round((decimal)SsWr, Tw, MidpointRounding.ToEven).ToString();
                Sc = Sc.Replace("0.", "");
                if (Fg[0] != null && Fg[1] != null) Sc = Fg[0] + Sc;
            }
            catch (Exception)
            {  }
            return Sc;
        }
private void SiLiu_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (SiLiu.Text != "四舍六入") XuanXiang.Enabled = false;
            else XuanXiang.Enabled = true;
        }        private void XuanXiang_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (XuanXiang.Text != "四舍五入") SiLiu.Enabled = false;
            else SiLiu.Enabled = true;
        }        private void ZzS_CheckedChanged(object sender, EventArgs e)
        { ZhuanHuang.Text = "[金额]中文→数字"; }        private void SzZ_CheckedChanged(object sender, EventArgs e)
        { ZhuanHuang.Text = "[金额]数字→中文"; }

Answer 2

其实发完这个代码后我脑海中清晰浮现出另外一种更好的逻辑与算法,比上面发布的更有逻辑性和更简洁算法,只是目前手头作另一个软件,所以,没时间来再写......
上面的发布这里了:http://blog.csdn.net/xianfajushi/article/details/7214070

Answer 3

佛慈悲,应要求给整个下载在我的资源中,其中包含自学习桌面编程以来所找的资料及未完成的部分学习代码,从未完成的开始转入了另一个急需开发软件的研发工作,所以没时间来作这个的继续,打包原封不动提供学习了.
其中包含鼠标拖放\ACCESS数据库创建\打开文件路径的一些学习资料，全靠找到的代码自己调试学习来的，这样学习方法迅速提高自己编程能力，而不依靠他人整个工程代码，当然，提供目前这个源码这些学习还算是很基础的。
http://download.csdn.net/detail/xianfajushi/4036198