这里有一个 XML 架构验证类

using System;
using System.Collections;
using System.IO;
using System.Xml;
using System.Xml.Schema;

namespace RapidTier
{
    /**//// <summary>
    /// Helper class to perform schema validations.
    /// </summary>
    public sealed class SchemaValidator
    {
        Private members#region Private members
        
        /**//// <summary>
        /// The schemas that will be used for validation.
        /// </summary>
        private ArrayList schemas = new ArrayList(2);

        /**//// <summary>
        /// The errors detected during the validation.
        /// </summary>
        private ArrayList errors = new ArrayList(5);

        /**//// <summary>
        /// Whether the document is valid or not.
        /// </summary>
        private bool isValid;

        #endregion

        Constructors#region Constructors

        /**//// <summary>
        /// Creates an instance of the SchemaValidator using the document and the schemas.
        /// </summary>
        /// <param name="document">The document to validate.</param>
        /// <param name="schemas">A list of schemas to validate the document against.</param>
        public SchemaValidator( string document, params Stream[] schemas )
        {
            this.schemas.Add( document );
            foreach(Stream s in schemas)
            {
                this.schemas.Add( s );
            }
            isValid = true;
        }

        #endregion

        Public members#region Public members

        /**//// <summary>
        /// Validates the document and returns the result of the validation.
        /// </summary>
        /// <returns><c>true</c> if the document have succeeded the validation, otherwise <c>false</c>.</returns>
        public bool Validate()
        {
            errors.Clear();
            XmlValidatingReader vr = null;
            object doc = schemas[0];
            if ( doc is Stream)
            {
                vr = new XmlValidatingReader( (Stream)doc, XmlNodeType.Element, null );
            }
            else if ( doc is String )
            {
                vr = new XmlValidatingReader( (string)doc, XmlNodeType.Element, null );
            }

            try
            {
                for(int i=1;i<schemas.Count;i++)
                {
                    vr.Schemas.Add( null, new XmlTextReader( (Stream)schemas[i] ) );
                }

                vr.ValidationEventHandler += new System.Xml.Schema.ValidationEventHandler(ValidationEventHandler);
            
                while( vr.Read() );
                return isValid;
            }
            finally
            {
                vr.Close();
            }
        }

        /**//// <summary>
        /// Contains the validation errors encountered in the last validation operation.
        /// </summary>
        public ValidationEventArgs[] Errors
        {
            get 
            { 
                return (ValidationEventArgs[])errors.ToArray(typeof(ValidationEventArgs) ); 
            }
        }

        /**//// <summary>
        /// Helper method to capture the event handlers.
        /// </summary>
        /// <param name="sender">The sender of the event.</param>
        /// <param name="e">The information about the event.</param>
        private void ValidationEventHandler(object sender, System.Xml.Schema.ValidationEventArgs e)
        {
            errors.Add( e );
            if ( e.Severity == XmlSeverityType.Warning )
            {
                return;
            }
            isValid = false;
        }

        #endregion
    }
}

　　二、使用XmlValidatingReader类验证读取Xml文档
　　 .Net程序集System.Xml包含了许多类，这些类用于在.Net平台上提供Xml功能。 XmlValidatingReader类（XmlReader类的一种实现）就是其中的一种。在将xml文档或Xml片段读入系统时，该类提供验证支持。它实现 DTD、XML 数据简化 (XDR) 架构和 XML 架构定义语言 (XSD) 架构等规范所定义的有效性约束。 

　　1、构造XmlValidatingReade类对象实例 
　　初始化XmlValidatingReader类的新实例有多种方法，最常用的一种是传入XmlReader类型的参数： 

　　作为XmlReader的具体实现之一，XmlTextReader类提供对Xml文档的快速、只前进、无缓存的读取，而XmlValidatingReader可以使用从XmlTextReader所返回的所有内容，并进一步提供验证支持。当然，如果一切正常，该过程不会造成信息丢失，从给定的 XmlReader 返回的所有节点和属性也都从此验证读取器返回。未从基础读取器返回的新节点可能由此读取器添加（例如，实体引用的默认属性和子级）。 

　　2、指定验证类型 
　　从前面已经能知道，有三种规范用于对xml文档执行验证。它们是DTD、XDR及XmlSchema。所以，在执行验证之前，需要确定验证的类型，这通过设置ValidatingReader类的ValidationType属性来完成： 

　　这行代码将验证声明为XSD Schema。 

　　3、使用XmlSchemaCollection类缓存架构 

　　如果需要根据XDR或者XSD Schema进行验证，可以使用XmlSchemaCollection类来缓存架构，这样将可以提高性能。XmlSchemaCollection类的Add方法加载架构，同时，架构会与命名空间 URI 关联。对于"XML 架构"的源文件(.xsd)来说，这通常会是架构的 targetNamespace 属性。 

　　当然，如果架构内联于Xml文档中，就不需要这样做了。 

　　4、关联架构缓存 

　　在向XmlSchemaCollection中添加完schema之后，XmlValidatingReader并不能自动识别并使用schema，还需要将两者关联起来。通过使用读取器的 Schemas 属性引用缓存在 XmlSchemaCollection 中的架构文件来完成这一过程： 

　　5、ValidationEventHandler事件处理程序回调 
　　在使用ValidatingReader执行验证读取Xml文档时，可能发生意外。这时，可以通过ValidationEventHandler 回调报告验证错误和警告。ValidationEventHandler 事件用于设置一个事件处理程序以接收有关文档类型定义 (DTD)、数据简化 XML (XDR) 和 XML 架构定义语言 (XSD) 架构验证错误的信息。 

　　不过，如果不提供 ValidationEventHandler，你依然可以使用通用的异常处理机制来捕捉错误。当发生分析错误时，将通过引发 XmlException 报告错误。如果发生验证错误，将引发 XmlSchemaException。当然，任何一种异常，将无法重新启动 XmlValidatingReader。 

　　指定事件及回调用遵循通用的做法：通过+=将XmlValidatingReader与事件处理程序ValidationEventHandler连接起来： 

　　参数vCallback是回调处理程序的方法名称，这个方法必须包含一个ValidationEventArgs类型的参数，ValidationEventArgs 类具有针对以下各项的属性：文本消息，表示 Error 或 Warning 的 XmlSeverityType 枚举，以及包含与特定验证错误关联的 XmlSchemaException 信息的异常。 

　　这一步不是必须的，如果你能保证错误不会发生或者发生就发生去吧！ 

　　6、执行验证读操作 

　　做完以上准备工作后，你可以使用XmlValidatingReader类的读方法开始验证读取Xml文档了。可以是 Read、ReadInnerXml、ReadOuterXml 中的任一种以及其他将改变接点的方法，如Skip（）方法。这时，都将发生验证。 

　　三、实例
　　综合以上知识，下面创建一个Windows Console控制台应用程序，用于在商务领域中处理产品数据，一般地，不同公司产品数据将遵循一定的格式，这里通过XSD 

　　Xsd，该架构文件对xml文档提供结构信息，用于在数据交换时遵循一致的标准 

　　根据上面的架构文件，下面构造了一个产品数据xml文档，这里使用了产品库内容的部分段落，为方便测试，让它成为了一个完整的xml文档： 

　　下面的应用程序对xml文档进行处理，并验证其数据是否是符合该架构的有效的！ 

1 几种调用扫描仪的方案http://hi.baidu.com/scutsolo/blog/item/89f9f0fadeb6c514a9d31170.html

2.用imgscan.ocx来扫描图像(转) http://blog.csdn.net/trnbo/archive/2004/11/09/174162.aspx

3.使用WIA Scripting
http://www.codeproject.com/dotnet/wiascriptingdotnet.asp

用twain_32.dll 的地址应该是
http://www.codeproject.com/dotnet/twaindotnet.asp?msg=333602&target=twain

4.http://blog.csdn.net/fenin/archive/2009/06/02/4237385.aspx在C#中使用WIA获取扫描仪数据（一）

5.http://www.cnblogs.com/bb5059619/archive/2008/07/29/1255916.html

6.http://space.cnblogs.com/question/13964/

7.利用wia和imgscan从扫描仪获取图像(vb6 c#)

wiaScan.rar

Scan_Twain.rar

twaingui_src.zip

imaScan和imgedit.rar

在“随风飘散” 博客里面，介绍了一个不错的DataGridView数据窗口控件《DataGridView数据窗口控件开发方法及其源码提供下载》，这种控件在有些场合下，还是非常直观的。因为，在一般要求客户录入数据的地方，一般有两种途径，其一是通过弹出一个新的窗口，在里面列出各种需要输入的要素，然后保存的，如下图所示；

其二就是直接在DataGridView中直接输入。这两种方式各有优劣，本文介绍采用该控件实现第二种模式的数据数据。如下图所示

 这种方式，直接通过在DataGridView中下拉列表或者文本框中输入内容，每列的数据可以联动或者做限制，实现用户数据的约束及规范化。

控件只要接受了DataTable的DataSource之后，会根据列的HeadText内容，显示表格的标题及内容，应用还是比较直观方便的。

由于列之间的数据输入等相关的影响需要处理，因此控件的处理方式是通过委托函数进行处理，如上面的部分代码中就是处理这些事件的。

由于本例子是通过输入内容后，及时更新数据库及控件的显示，因此需要对该事件进行处理，处理代码如下所示。

另外，该控件还提供了一个用于对话框窗体中的复杂下拉列表的数据显示方式，控件支持内容的过滤检索，非常方便实用，如下所示

该控件的使用代码如下所示：

在开发Winform程序的时候，经常会用到等待窗口（如网络通讯、数据库连接等需要一定时间来执行的操作），这样可以给用户提供更好的体验。

         等待窗口的主要功能是一边执行需要等待的操作，一边显示一个等待界面。当执行完毕时等待界面消失。用户可以提前取消操作，还可以设置操作的最大等待时间，若超过指定时间仍没完成操作可结束当前操作。等待窗口的操作处理内容可用λ表达式，在后面的应用实例中可看到使用方法。

         实现界面如下图：

         等待界面主要包含的部分：

• 等待图片；
• 等待消息文字("正在处理数据，请稍后...")：可自定义；
• 计时器：可设置不显示；
• 取消返回按钮：可设置不显示；
• 另外等待窗口显示和关闭的时候都有渐变的一个简单特效，等待窗口的颜色是在一定范围内随即的。

等待窗口实现代码：

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 WinForm_Test
{
    public partial class frmWaitingBox : Form
    {
        #region Properties
        private int _MaxWaitTime;
        private int _WaitTime;
        private bool _CancelEnable;
        private IAsyncResult _AsyncResult;
        private EventHandler<EventArgs> _Method;
        private bool _IsShown = true;
        private readonly int _EffectCount = 10;
        private readonly int _EffectTime = 500;
        /// <summary>
        /// 控制界面显示的特性
        /// </summary>
        private Timer _Timer;
        public string Message { get; private set; }
        public int TimeSpan { get; set; }
        public bool FormEffectEnable { get; set; }
        #endregion

        #region frmWaitingBox
        public frmWaitingBox(EventHandler<EventArgs> method,int maxWaitTime,string waitMessage,bool cancelEnable,bool timerVisable)
        {
            maxWaitTime *= 1000;
            Initialize(method, maxWaitTime,waitMessage, cancelEnable, timerVisable);
        }
        public frmWaitingBox(EventHandler<EventArgs> method)
        {
            int maxWaitTime=60*1000;
            string waitMessage = "正在处理数据，请稍后...";
            bool cancelEnable=true;
            bool timerVisable=true;
            Initialize(method, maxWaitTime,waitMessage, cancelEnable, timerVisable);
        }
        public frmWaitingBox(EventHandler<EventArgs> method, string waitMessage)
        {
            int maxWaitTime = 60 * 1000;
            bool cancelEnable = true;
            bool timerVisable = true;
            Initialize(method, maxWaitTime, waitMessage, cancelEnable, timerVisable);
        }
        public frmWaitingBox(EventHandler<EventArgs> method, bool cancelEnable, bool timerVisable)
        {
            int maxWaitTime = 60*1000;
            string waitMessage = "正在处理数据，请稍后...";
            Initialize(method, maxWaitTime,waitMessage, cancelEnable, timerVisable);
        }
        #endregion

        #region Initialize
        private void Initialize(EventHandler<EventArgs> method, int maxWaitTime,string waitMessage,bool cancelEnable, bool timerVisable)
        {
            InitializeComponent();
            //initialize form
            this.FormBorderStyle = FormBorderStyle.None;
            this.StartPosition = FormStartPosition.CenterParent;
            this.ShowInTaskbar = false;
            Color[] c = GetRandColor();
            this.panel1.BackColor = c[0];
            this.BackColor = c[1];
            this.labMessage.Text = waitMessage;
            _Timer = new Timer();
            _Timer.Interval = _EffectTime/_EffectCount;
            _Timer.Tick += _Timer_Tick;
            this.Opacity = 0;
            FormEffectEnable = true;
            //para
            TimeSpan = 500;
            Message = string.Empty;
            _CancelEnable = cancelEnable;
            _MaxWaitTime = maxWaitTime;
            _WaitTime = 0;
            _Method = method;
            this.pictureBoxCancel.Visible = _CancelEnable;
            this.labTimer.Visible = timerVisable;
            this.timer1.Interval = TimeSpan;
            this.timer1.Start();
        }
        #endregion

        #region Color
        private Color[] GetRandColor()
        {
            int rMax = 248;
            int rMin = 204;
            int gMax = 250;
            int gMin = 215;
            int bMax = 250;
            int bMin = 240;
            Random r = new Random(DateTime.Now.Millisecond);
            int r1 = r.Next(rMin, rMax);
            int r2 = r1 + 5;
            int g1 = r.Next(gMin, gMax);
            int g2 = g1 + 5;
            int b1 = r.Next(bMin, bMax);
            int b2 = b1 + 5;
            Color c1 = Color.FromArgb(r1, g1, b1);
            Color c2 = Color.FromArgb(r2, g2, b2);
            Color[] c = { c1, c2 };
            return c;
        }
        #endregion

        #region Events
        private void btnCancel_Click(object sender, EventArgs e)
        {
            this.Message = "您结束了当前操作！";
            this.Close();
        }

        private void timer1_Tick(object sender, EventArgs e)
        {
            _WaitTime += TimeSpan;
            this.labTimer.Text = string.Format("{0}秒", _WaitTime / 1000);
            if (!this._AsyncResult.IsCompleted)
            {
                if (_WaitTime > _MaxWaitTime)
                {
                    Message = string.Format("处理数据超时{0}秒，结束当前操作！", _MaxWaitTime / 1000);
                    this.Close();
                }
            }
            else
            {
                this.Message = string.Empty;
                this.Close();
            }
            
        }

        private void frmWaitingBox_Shown(object sender, EventArgs e)
        {
            _AsyncResult = _Method.BeginInvoke(null, null, null, null);
            //Effect
            if (FormEffectEnable)
            {
                _Timer.Start();
            }
            else
                this.Opacity = 1;
        }
        private void frmWaitingBox_FormClosing(object sender, FormClosingEventArgs e)
        {
            if (FormEffectEnable)
            {
                if(this.Opacity>=1)
                    e.Cancel = true;
                _Timer.Start();
            }
        }
        private void _Timer_Tick(object sender, EventArgs e)
        {
            if (_IsShown)
            {
                if (this.Opacity >= 1)
                {
                    _Timer.Stop();
                    _IsShown = false;
                }
                this.Opacity += 1.00 / _EffectCount;
            }
            else
            {
                if (this.Opacity <= 0)
                {
                    _Timer.Stop();
                    _IsShown = true;
                    this.Close();
                }
                this.Opacity -= 1.00 / _EffectCount;
            }
        }
        #endregion

        
    }
}

应用实例代码：

string res;
 DataTable dt=null;
 frmWaitingBox f = new frmWaitingBox((obj,args)=>
     {
         Thread.Sleep(5000);
         string sql = "SELECT * FROM [test].[dbo].[studentInfo]";
         SQLHelper sqlHelper=new SQLHelper();
         dt = sqlHelper.ExecuteSqlStr(sql,out res);
     });
 f.ShowDialog(this);

 dataGridView1.DataSource = dt;

源码下载：下载地址——（http://files.cnblogs.com/anding/WinForm_Test1.rar）

快捷键在WinForm软件中必不可少，可以提高使用者的效率，下面就来看看怎样在我们的窗体中加上快捷键，新建一个Windows应用程序（我将解决方案命名为Keybd_Test，项目名为UI）。删掉自动生成的Form1.cs窗体，新建MainForm.cs窗体。调整大小，将StartPosition设置为CenterScreen，让窗体一运行就可以居中；将ShowIcon设置为false，去掉窗体标题栏的图标，现在什么控件也不加：

每个窗体都有这样3个事件：KeyDown、KeyPress、KeyUp，KeyDown和KeyPress都是按键按下事件，但KeyDown用的是KeyCode跟键盘各个按键相对应，它对应Keys枚举，用起来比较方便；而KeyPress用的是KeyChar，这个就要找ASC II编码了，不方便。KeyUp是按键弹起事件，不常用，因此我们使用KeyDown事件来设置窗体的快捷键，双击该事件后的空白生成代码，首先我们设置单个按键，让它按下F11最大化，再次按下还原，在事件中加入如下代码：

若窗体的WindowState为Maximized则还原，否则最大化，运行下试试，很好用 :-)

下面在窗体中加入一个名为txtInput的TextBox，两个名为btnConfirm、btnExit的Button：

再次运行窗体，按下F11，不起作用了？这是怎么回事？

因为这时窗体运行后，焦点已不在窗体上，而在控件上了，我们要将窗体的KeyPreview设置为True，向窗体注册控件上产生的键盘事件，再次运行，问题解决了。

那么组合按键又怎么设置呢？例如要按下Alt和数字0，需要这样：

使用Modifiers可设置组合键，键盘数字区按键的Keys枚举以D打头，而小键盘上的数字以NumPad打头。按下Ctrl与Shift组合键的方法与其类似，下面我们看看按下Ctrl + Alt + 数字0该怎样设置：

将Ctrl和Alt的枚举转换为int型相加后与Modifiers对比，这样即可判断是否按下了该组合键。

另外的，与窗体的AcceptButton属性相关联的按钮，将与键盘上的Enter键对应；与窗体的CancelButton属性相关联的按钮，将与键盘上的Ecs键对应。

在设置Button的Text属性时，在一个英文字母的前面加上&（and符），例如将btnConfirm的Text属性设置为：&Confirm，当运行窗体，按下Alt + C时，就相当于按下该键。

上面的示例名为Keybd_Test，点击这里下载（用VS 2005创建，.NET版本2.0）。

一、通过SendMessage或postmessage函数发送：

1、  定义消息
在C++中引用底层的函数很简单，自定义消息如下
#define WM_TEST WM_USER + 101
而在c#中消息需要定义成windows系统中的原始的16进制数字，比如自定义消息
public const int USER = 0x0400;

 public const int WM_TEST = USER +101;

2、  发送消息
消息发送是通过windows提供的API函数SendMessage或postmessage来实现的，它的原型定义：        

[DllImport("User32.dll",EntryPoint="SendMessage")]
          private static extern int SendMessage(
            IntPtr hWnd,      // 窗体句柄
            uint Msg,         // 消息的标识符
            uint wParam,      // 具体取决于消息
            uint lParam       // 具体取决于消息
       );

[DllImport("User32.dll",EntryPoint="PostMessage")]
          private static extern int SendMessage(
            IntPtr hWnd,      // 接收消息的那个窗口的句柄。如设为HWND_BROADCAST，表示投递给系统中的所有顶级窗口。如设为零，表示投递一条线程消息（可参考PostThreadMessage）
            uint Msg,         // 消息的标识符
            uint wParam,      // 具体取决于消息
            uint lParam       // 具体取决于消息
       );

至于两个函数的区别这里就不累述了，有兴趣的朋友可以自己查阅资料。

二、使用PostThreadMessage函数向线程发送消息

 1、映射消息结构体原型和自定义消息

public struct tagMSG
        {
            public int hwnd;
            public uint message;
            public int wParam;
            public long lParam;
            public uint time;
            public int pt;
        }

public const int WM_CX_NULL = 0x400 + 100;

2、发送消息

[DllImport("user32.dll")]

private static extern int PostThreadMessage(

　　　　　　　　　　　　　　　　　　int threadId,   //线程标识

 　　　　　　　　　　　　　　　　　　uint msg,      //消息标识符

　　　　　　　　　　　　　　　　　　int wParam,   //具体由消息决定

 　　　　　　　　　　　　　　　　　　int lParam);  //具体由消息决定

此函数获取当前线程一个唯一的线程标识符，这点需要特别注意：Win32 API无法识别管理线程，你必须发送消息到Windows的线程ID上，而不是管理线程的ID上。

[DllImport("kernel32.dll")]

private static extern int GetCurrentThreadId();

因此发送消息过程如下：

private int _NewThreadId = GetCurrentThreadId();

PostThreadMessage(_NewThreadId, WM_CX_NULL, 1, 1);

3、接收消息

该函数从调用线程的消息队列里取得一个消息并将其放于指定的结构。此函数可取得与指定窗口联系的消息和由PostThreadMesssge寄送的线程消息。此函数接收一定范围的消息值。GetMessage不接收属于其他线程或应用程序的消息

[DllImport("user32.dll")]
private static extern int GetMessage(

　　　　　　　　　　　　　　　　　　ref tagMSG lpMsg, //指向MSG结构的指针，该结构从线程的消息队列里接收消息信息;

　　　　　　　　　　　　　　　　　　int hwnd,       //取得其消息的窗口的句柄。这是一个有特殊含义的值（NULL）。GetMessage为任何属于调用线程的窗口检索消息;　　　　　　　　　　　　　　　　　　　　　　　　　　　　    　　　　　　　　　　　　　　　　 int wMsgFilterMin,     //指定被检索的最小消息值的整数

　　　　　　　　　　　　　　　　　　int wMsgFilterMax);    //指定被检索的最大消息值的整数

接收实现如下：

 public void ThreadExectue()
        {
            _NewThreadId = GetCurrentThreadId();  //发送线程和接收线程一定要是同一个线程，否则接收不到消息
            while (GetMessage(ref msg, 0, 0, 0) > 0)
            {
                if (msg.message == WM_CX_NULL)
                {
                    MessageBox.Show("消息收到！");
                }
            }
        }

获取strCpu = myObject.Properties["Processorid"].Value.ToString();时，请判断下返回是否为null，为null的话就说明cpu不支持。
获取集合对象属性，除非100%确定，否则不要直接访问属性。一旦返回空，就会报空引用错误

代码

 using System.Management;//需要在项目中添加System.Management引用

namespace ECBC_CDKEY
{
    public class SoftReg
    {
        /// <summary>
        /// 取得设备硬盘的卷标号
        /// </summary>
        /// <returns></returns>
        public string GetDiskVolumeSerialNumber()
        {
            ManagementClass mc = new ManagementClass("Win32_NetworkAdapterConfiguration");
            ManagementObject disk = new ManagementObject("win32_logicaldisk.deviceid=\"c:\"");
            disk.Get();
            return disk.GetPropertyValue("VolumeSerialNumber").ToString();
        }

        /// <summary>
        /// 获得CPU的序列号
        /// </summary>
        /// <returns></returns>
        public string getCpu()
        {
            string strCpu = null;
            ManagementClass myCpu = new ManagementClass("win32_Processor");
            ManagementObjectCollection myCpuConnection = myCpu.GetInstances();
            foreach (ManagementObject myObject in myCpuConnection)
            {
                strCpu = myObject.Properties["Processorid"].Value.ToString();
                break;
            }
            return strCpu;
        }
        
        /// <summary>
        /// 生成机器码
        /// </summary>
        /// <returns></returns>
        public string getMNum()
        {
            string strNum = getCpu() + GetDiskVolumeSerialNumber();//获得24位Cpu和硬盘序列号
            string strMNum = strNum.Substring(0, 24);//从生成的字符串中取出前24个字符做为机器码
            return strMNum;
        }
        public int[] intCode = new int[127];//存储密钥
        public int[] intNumber = new int[25];//存机器码的Ascii值
        public char[] Charcode = new char[25];//存储机器码字
        public void setIntCode()//给数组赋值小于10的数
        {
            for (int i = 1; i < intCode.Length; i++)
            {
                intCode[i] = i % 9;
            }
        }
        
        /// <summary>
        /// 生成注册码
        /// </summary>
        /// <returns></returns>
        public string getRNum()
        {
            setIntCode();//初始化127位数组
            string MNum = this.getMNum();//获取注册码
            for (int i = 1; i < Charcode.Length; i++)//把机器码存入数组中
            {
                Charcode[i] = Convert.ToChar(MNum.Substring(i - 1, 1));
            }
            for (int j = 1; j < intNumber.Length; j++)//把字符的ASCII值存入一个整数组中。
            {
                intNumber[j] = intCode[Convert.ToInt32(Charcode[j])] + Convert.ToInt32(Charcode[j]);
            }
            string strAsciiName = "";//用于存储注册码
            for (int j = 1; j < intNumber.Length; j++)
            {
                if (intNumber[j] >= 48 && intNumber[j] <= 57)//判断字符ASCII值是否0－9之间
                {
                    strAsciiName += Convert.ToChar(intNumber[j]).ToString();
                }
                else if (intNumber[j] >= 65 && intNumber[j] <= 90)//判断字符ASCII值是否A－Z之间
                {
                    strAsciiName += Convert.ToChar(intNumber[j]).ToString();
                }
                else if (intNumber[j] >= 97 && intNumber[j] <= 122)//判断字符ASCII值是否a－z之间
                {
                    strAsciiName += Convert.ToChar(intNumber[j]).ToString();
                }
                else//判断字符ASCII值不在以上范围内
                {
                    if (intNumber[j] > 122)//判断字符ASCII值是否大于z
                    {
                        strAsciiName += Convert.ToChar(intNumber[j] - 10).ToString();
                    }
                    else
                    {
                        strAsciiName += Convert.ToChar(intNumber[j] - 9).ToString();
                    }
                }
            }
            return strAsciiName;//返回注册码
        }
    }
}