今天在做一个OA的简单增删除该查的时候，有一个时间类型的字段（数据插入时间），本身想着，这个字段直接中Oracle数据库设置一个Default Value ，就不用再前台install这个字段的值了，但是后时间操作中发现插入的时候如果不通过hql去写代码的话，而是通过hibernate的接口getHibernateTemplate().saveOrUpdate(entity);的话，就出现问题，插入的时间类型字段的值是null，tmd有点郁闷，不好意思又说脏话了，也是当时头有点昏，呵呵。后来，一想如果通过getHibernateTemplate().saveOrUpdate(entity);这个借口，如果没有设置值，那么就会设置null，所有出现了这个问题。查看了下hibernate的接口文档，一看，原来是这样的。

需要添加下面的参数在*.hbm.xml中class节点设置，如下

一是将dynamic-insert设置为true

二是将对应字段的属性设置not-null为false

<hibernate-mapping>
<class name="com.tom.hibernate.xxxx" table="xxx schema="xxx" dynamic-insert="true" dynamic-update="true">

<property name="entryDate" type="java.util.Date">
<column name="ENTRY_DATE" length="7" not-null="false"/>
</property>

用拿来主义）贴过来一个这个接口说明：

下面是有关其它配置的说明

Hibernate允许我们在映射文件里控制insert和update语句的内容.比如在映射文件中<property 元素中的update属性设置成为false,那么这个字段,将不被包括在基本的update语句中,修改的时候,将不包括这个字段了.insert同理.dynamic动态SQL语句的配置也是很常用的.下面介绍配置SQL语句的具体属性:
1)<property>元素 insert属性:设置为false,在insert语句中不包含这个字段,表示永远不会被插入,默认true
2)<property>元素 update属性:设置为false,在update语句中不包含这个字段,表示永远不会被修改,默认true
3)<class>元素 mutable属性:设置为false就是把所有的<property>元素的update属性设置为了false,说明这个对象不会被更新,默认true
4)<property>元素 dynamic-insert属性:设置为true,表示insert对象的时候,生成动态的insert语句,如果这个字段的值是null就不会加入到insert语句当中.默认false
5)<property>元素 dynamic-update属性,设置为true,表示update对象的时候,生成动态的update语句,如果这个字段的值是null就不会被加入到update语句中,默认false
6)<class>元素 dynamic-insert属性:设置为true,表示把所有的<property>元素的dynamic-insert属性设置为true,默认false
7)<class>元素 dynamic-update属性:设置为true,表示把所有的<property>元素的dynamic-update属性设置为true,默认false

Hibernate生成动态SQL语句的消耗的系统资源(比如CPU,内存等)是很小的,所以不会影响到系统的性能,如果表中包含N多字段,建议把dynamic-update属性和insert属性设置为true,这样在插入和修改数据的时候,语句中只包括要插入或者修改的字段.可以节省SQL语句的执行时间,提高程序的运行效率.

另外一种做法请看如下配置：

Hibernate <property>配置

本文介绍两种为Dll库(OCX)自动注册的方法，为大家提供参考。

首先，大家都知道在Windows的“运行”中，输入“Regsvr32.exe 路径”这样的方法来手动注册Dll控件(OCX)，显示这种方法对于程序的自动化部署等带来极大的不便，
因此，今天我们着重介绍如何用C#实现自动注册。

方法一：调用Regsvr32法

既然可以在运行栏中输入“Regsvr32.exe 路径”的方法来注册，那么，一定可以在C#程序中采用同样的方法来调用Regsvr32，以实现注册：

Process p = new Process();
p.StartInfo.FileName = "Regsvr32.exe";
p.StartInfo.Arguments = "/s C:\\DllTest.dll";//路径中不能有空格
p.Start();
采用这种方法，注意要添加对命名空间System.Diagnostics的引用：using System.Diagnostics;
另外，这种方法有一个不足之处，那就是注册工作是在本程序之外由Regsvr32.exe程序来完成的，系统内不方便知道注册的结果，也不方便对注册过程弹出的对话框进行自定义和控制。
这里附Regsvr32的参数说明：(感谢网友伍华聪的提醒)

regsvr32.exe是32位系统下使用的DLL注册和反注册工具，使用它必须通过命令行的方式使用，格式是：

　　regsvr32 [/u] [/s] [/n] [/i[:cmdline]] DLL文件名

　　命令可以在“开始→运行”的文本框中，也可以事先在bat批处理文档中编写好命令。未带任何参数是注册DLL文件功能，其它参数对应功能如下：

　　/u：反注册DLL文件;

　　/s：安静模式(Silent)执行命令，即在成功注册/反注册DLL文件前提下不显示结果提示框。

　　/c：控制端口;

　　/i：在使用/u反注册时调用DllInstall;

　　/n：不调用DllRegisterServer，必须与/i连用。

方法二：调用DllRegisterServer函数法

 研究Regsvr32.exe和Dll文件，我们会发现，其实每个需要注册的文件都包括一个DllRegisterServer()方法，Regsvr32.exe就是通过调用该方法来完成Dll的注册的。
知道了这个，我们就可以自己调用DllRegisterServer()来完成注册过程啦。

首先，还得引入外部方法：

[DllImport("DllTest.dll")]
public static extern int DllRegisterServer();//注册时用
[DllImport("DllTest.dll")]
public static extern int DllUnregisterServer();//取消注册时用

接下来就不难啦：int i = DllRegisterServer();
if (i >= 0)
{
    //注册成功!
}
else
{
    //注册失败
}
取消注册的过程就不应再贴代码啦。
 

如何对Dll是否已经注册过了做出判断？
一般情况下，我们可以将对Dll控件的注册过程放在系统启动的过程中来完成，但是，总不能每次启动都注册一次吧？这样做显然不合理。
那么，我们就来判断一下，当前Dll是否已经注册过，如果已注册过，就跳过注册过程。

每一个Dll的注册都会在注册表里记录下有关它本身的资料，如注册路径，唯一ID等。我们这里就是利用它留下的唯一ID号来判断：

RegistryKey rkTest = Registry.ClassesRoot.OpenSubKey("CLSID\\{7713F78A-44DE-42BA-A1F6-3FB0BD6CA63B}\\");
if (rkTest == null)
{  
 //Dll没有注册，在这里调用DllRegisterServer()吧
｝
注意要添加对命名空间Microsoft.Win32的引用：using Microsoft.Win32;

其中的“{7713F78A-44DE-42BA-A1F6-3FB0BD6CA63B}”就是该Dll的唯一ID啦，每一个Dll文件都会不一样的。

但是，问题又来了，怎么样知道它的唯一ID呢？其实很简单，那就是“逆向思维”。
我们可先注册这个Dll文件，然后到注册表的“HKEY_CLASSES_ROOT\CLSID”分支下“查找”Dll的名称或路径，就可以看到这个ID啦。  

(注：在devexpress控件中用DevExpress.Data.CurrencyDataController.DisableThreadingProblemsDetection = true;)

    用户不喜欢反应慢的程序。在执行耗时较长的操作时，使用多线程是明智之举，它可以提高程序 UI 的响应速度，使得一切运行显得更为快速。在 Windows 中进行多线程编程曾经是 C++ 开发人员的专属特权，但是现在，可以使用所有兼容 Microsoft .NET 的语言来编写。

不过Windows 窗体体系结构对线程使用制定了严格的规则。如果只是编写单线程应用程序，则没必要知道这些规则，这是因为单线程的代码不可能违反这些规则。然而，一旦采用多线程，就需要理解 Windows 窗体中最重要的一条线程规则：除了极少数的例外情况，否则都不要在它的创建线程以外的线程中使用控件的任何成员。本规则的例外情况有文档说明，但这样的情况非常少。这适用于其类派生自 System.Windows.Forms.Control 的任何对象，其中几乎包括 UI 中的所有元素。所有的 UI 元素（包括表单本身）都是从 Control 类派生的对象。此外，这条规则的结果是一个被包含的控件（如，包含在一个表单中的按钮）必须与包含它控件位处于同一个线程中。也就是说，一个窗口中的所有控件属于同一个 UI 线程。实际中，大部分 Windows 窗体应用程序最终都只有一个线程，所有 UI 活动都发生在这个线程上。这个线程通常称为 UI 线程。这意味着您不能调用用户界面中任意控件上的任何方法，除非在该方法的文档说明中指出可以调用。该规则的例外情况（总有文档记录）非常少而且它们之间关系也不大。请注意，以下代码是非法的：

        private Thread myThread;

        private void Form1_Load(object sender, EventArgs e)

        {

            myThread = new Thread(new ThreadStart(RunsOnWorkerThread));

            myThread.Start();

        }

        private void RunsOnWorkerThread()

        {

            label1.Text = "myThread线程调用UI控件";

    }

如果您在 .NET Framework 1.0 版本中尝试运行这段代码，也许会侥幸运行成功，或者初看起来是如此。这就是多线程错误中的主要问题，即它们并不会立即显现出来。甚至当出现了一些错误时，在第一次演示程序之前一切看起来也都很正常。但不要搞错 — 我刚才显示的这段代码明显违反了规则，并且可以预见，任何抱希望于“试运行时良好，应该就没有问题”的人在即将到来的调试期是会付出沉重代价的。

下面我们来看看有哪些方法可以解决这一问题。

一、System.Windows.Forms.MethodInvoker 类型是一个系统定义的委托，用于调用不带参数的方法。
        private Thread myThread;

        private void Form1_Load(object sender, EventArgs e)

        {

            myThread = new Thread(new ThreadStart(RunsOnWorkerThread));

            myThread.Start();

        }

        private void RunsOnWorkerThread()

        {

            MethodInvoker mi = new MethodInvoker(SetControlsProp);

            BeginInvoke(mi);

        }

        private void SetControlsProp()

        {

            label1.Text = "myThread线程调用UI控件";

        }

二、直接用System.EventHandle（可带参数）

        private Thread myThread;

        private void Form1_Load(object sender, EventArgs e)

        {

            myThread = new Thread(new ThreadStart(RunsOnWorkerThread));

            myThread.Start();

        }

        private void RunsOnWorkerThread()

        {

            //DoSomethingSlow();

            string pList = "myThread线程调用UI控件";

            label1.BeginInvoke(new System.EventHandler(UpdateUI), pList);

        }

        //直接用System.EventHandler,没有必要自定义委托

        private void UpdateUI(object o, System.EventArgs e)

        {

           //UI线程设置label1属性

            label1.Text = o.ToString() + "成功!";

        }

三、包装 Control.Invoke

虽然第二个方法中的代码解决了这个问题，但它相当繁琐。如果辅助线程希望在结束时提供更多的反馈信息，而不是简单地给出“Finished!”消息，则 BeginInvoke 过于复杂的使用方法会令人生畏。为了传达其他消息，例如“正在处理”、“一切顺利”等等，需要设法向 UpdateUI 函数传递一个参数。可能还需要添加一个进度栏以提高反馈能力。这么多次调用 BeginInvoke 可能导致辅助线程受该代码支配。这样不仅会造成不便，而且考虑到辅助线程与 UI 的协调性，这样设计也不好。对这些进行分析之后，我们认为包装函数可以解决这两个问题。

        private Thread myThread;

        private void Form1_Load(object sender, EventArgs e)

        {

            myThread = new Thread(new ThreadStart(RunsOnWorkerThread));

            myThread.Start();

        }

        private void RunsOnWorkerThread()

        {

            ////DoSomethingSlow();

            for (int i = 0; i < 100; i++)

            {

                ShowProgress( Convert.ToString(i)+"%", i);

                Thread.Sleep(100);

            }

        }

        public void ShowProgress(string msg, int percentDone)

        {

            // Wrap the parameters in some EventArgs-derived custom class:

            System.EventArgs e = new MyProgressEvents(msg, percentDone);

            object[] pList = { this, e };

            BeginInvoke(new MyProgressEventsHandler(UpdateUI), pList);

        }

        private delegate void MyProgressEventsHandler(object sender, MyProgressEvents e);

        private void UpdateUI(object sender, MyProgressEvents e)

        {

            lblStatus.Text = e.Msg;

            myProgressControl.Value = e.PercentDone;

       }

    public class MyProgressEvents : EventArgs

    {

        public string Msg;

        public int PercentDone;

        public MyProgressEvents(string msg, int per)

        {

            Msg = msg;

            PercentDone = per;

        }

}

ShowProgress 方法对将调用引向正确线程的工作进行封装。这意味着辅助线程代码不再担心需要过多关注 UI 细节，而只要定期调用 ShowProgress 即可。

如果我提供一个设计为可从任何线程调用的公共方法，则完全有可能某人会从 UI 线程调用这个方法。在这种情况下，没必要调用 BeginInvoke，因为我已经处于正确的线程中。调用 Invoke 完全是浪费时间和资源，不如直接调用适当的方法。为了避免这种情况，Control 类将公开一个称为 InvokeRequired 的属性。这是“只限 UI 线程”规则的另一个例外。它可从任何线程读取，如果调用线程是 UI 线程，则返回假，其他线程则返回真。这意味着我可以按以下方式修改包装：

        public void ShowProgress(string msg, int percentDone)

        {

            if (InvokeRequired)

            {

                // As before

                //...

            }

            else

            {

                // We're already on the UI thread just

                // call straight through.

                UpdateUI(this, new MyProgressEvents(msg,PercentDone));

            }

        }

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/jackey0517/archive/2009/09/08/4533458.aspx

Control.BeginInvoke 方法 (Delegate) :在创建控件的基础句柄所在线程上异步执行指定委托。

(一）Control的Invoke和BeginInvoke
我们要基于以下认识：
（1）Control的Invoke和BeginInvoke与Delegate的Invoke和BeginInvoke是不同的。
（2）Control的Invoke和BeginInvoke的参数为delegate，委托的方法是在Control的线程上执行的，也就是我们平时所说的UI线程。

我们以代码(一)来看(Control的Invoke)
private delegate void InvokeDelegate();
private void InvokeMethod(){
   //C代码段
}
private void butInvoke_Click(object sender, EventArgs e) {
   //A代码段.......
   this.Invoke(new InvokeDelegate(InvokeMethod));
   //B代码段......
}
你觉得代码的执行顺序是什么呢?记好Control的Invoke和BeginInvoke都执行在主线程即UI线程上
A------>C---------------->B
解释：(1)A在UI线程上执行完后，开始Invoke，Invoke是同步
(2)代码段B并不执行，而是立即在UI线程上执行InvokeMethod方法，即代码段C。
(3)InvokeMethod方法执行完后，代码段C才在UI线程上继续执行。

看看代码(二)，Control的BeginInvoke
private delegate void BeginInvokeDelegate();
private void BeginInvokeMethod(){
   //C代码段
}
private void butBeginInvoke_Click(object sender, EventArgs e) {
   //A代码段.......
   this.BeginInvoke(new BeginInvokeDelegate(BeginInvokeMethod));
   //B代码段......
}
你觉得代码的执行顺序是什么呢?记好Control的Invoke和BeginInvoke都执行在主线程即UI线程上
A----------->B--------------->C慎重，这个只做参考。。。。。，我也不肯定执行顺序，如果有哪位达人知道的话请告知。
解释：：(1)A在UI线程上执行完后，开始BeginInvoke，BeginInvoke是异步
(2)InvokeMethod方法，即代码段C不会执行，而是立即在UI线程上执行代码段B。
(3)代码段B执行完后(就是说butBeginInvoke_Click方法执行完后)，InvokeMethod方法，即代码段C才在UI线程上继续执行。

由此，我们知道：
Control的Invoke和BeginInvoke的委托方法是在主线程，即UI线程上执行的。也就是说如果你的委托方法用来取花费时间长的数据，然后更新界面什么的，千万别在UI线程上调用Control.Invoke和Control.BeginInvoke，因为这些是依然阻塞UI线程的，造成界面的假死。

那么，这个异步到底是什么意思呢?

异步是指相对于调用BeginInvoke的线程异步，而不是相对于UI线程异步，你在UI线程上调用BeginInvoke ，当然不行了。－－－－摘自"Invoke和BeginInvoke的真正涵义"一文中的评论。
BeginInvoke的原理是将调用的方法Marshal成消息，然后调用Win32 API中的RegisterWindowMessage()向UI窗口发送消息。－－－－摘自"Invoke和BeginInvoke的真正涵义"一文中的评论。

(二)我们用Thread来调用BeginInvoke和Invoke
      我们开一个线程，让线程执行一些耗费时间的操作，然后再用Control.Invoke和Control.BeginInvoke回到用户UI线程，执行界面更新。

代码(三)  Thread调用Control的Invoke
private Thread invokeThread;
private delegate void invokeDelegate();
private void StartMethod(){
   //C代码段......
   Control.Invoke(new invokeDelegate(invokeMethod));
  //D代码段......
}
private void invokeMethod(){
  //E代码段
}
private void butInvoke_Click(object sender, EventArgs e) {
   //A代码段.......
   invokeThread = new Thread(new ThreadStart(StartMethod));
   invokeThread.Start();
   //B代码段......
}
你觉得代码的执行顺序是什么呢?记好Control的Invoke和BeginInvoke都执行在主线程即UI线程上
A------>(Start一开始B和StartMethod的C就同时执行)---->(C执行完了，不管B有没有执行完，invokeThread把消息封送(invoke)给UI线程，然后自己等待)---->UI线程处理完butInvoke_Click消息后，处理invokeThread封送过来的消息，执行invokeMethod方法，即代码段E，处理往后UI线程切换到invokeThread线程。
这个Control.Invoke是相对于invokeThread线程同步的，阻止了其运行。

解释：
1。UI执行A
2。UI开线程InvokeThread，B和C同时执行，B执行在线程UI上，C执行在线程invokeThread上。
3。invokeThread封送消息给UI，然后自己等待，UI处理完消息后，处理invokeThread封送的消息，即代码段E
4。UI执行完E后，转到线程invokeThread上，invokeThread线程执行代码段D

代码(四)  Thread调用Control的BeginInvoke
private Thread beginInvokeThread;
private delegate void beginInvokeDelegate();
private void StartMethod(){
   //C代码段......
   Control.BeginInvoke(new beginInvokeDelegate(beginInvokeMethod));
  //D代码段......
}
private void beginInvokeMethod(){
  //E代码段
}
private void butBeginInvoke_Click(object sender, EventArgs e) {
   //A代码段.......
   beginInvokeThread = new Thread(new ThreadStart(StartMethod));
   beginInvokeThread .Start();
   //B代码段......
}
你觉得代码的执行顺序是什么呢?记好Control的Invoke和BeginInvoke都执行在主线程即UI线程上
A在UI线程上执行----->beginInvokeThread线程开始执行，UI继续执行代码段B，并发地invokeThread执行代码段C-------------->不管UI有没有执行完代码段B，这时beginInvokeThread线程把消息封送给UI，单自己并不等待，继续向下执行-------->UI处理完butBeginInvoke_Click消息后，处理beginInvokeThread线程封送过来的消息。

解释：
1。UI执行A
2。UI开线程beginInvokeThread，B和C同时执行，B执行在线程UI上，C执行在线程beginInvokeThread上。
3。beginInvokeThread封送消息给UI，然后自己继续执行代码D，UI处理完消息后，处理invokeThread封送的消息，即代码段E
有点疑问：如果UI先执行完毕，是不是有可能过了段时间beginInvokeThread才把消息封送给UI，然后UI才继续执行封送的消息E。如图浅绿的部分。


Control的BeginInvoke是相对于调用它的线程，即beginInvokeThread相对是异步的。
因此，我们可以想到。如果要异步取耗费长时间的数据，比如从数据库中读大量数据，我们应该这么做。
(1)如果你想阻止调用线程，那么调用代码(三)，代码段D删掉，C改为耗费长时间的操作，因为这个操作是在另外一个线程中做的。代码段E改为更新界面的方法。
(2)如果你不想阻止调用线程，那么调用代码(四)，代码段D删掉，C改为耗费长时间的操作，因为这个操作是在另外一个线程中做的。代码段E改为更新界面的方法。

==============================以上是原帖=============================

       我认为上面“代码二”给出的运行结果是正确的。我来做个总结：委托的同步和异步的区别，只有在多线程中才能体现的出来。以跨线程操作控件为例，采用异步时则向UI线程发送一个消息，然后该干嘛干嘛，这个消息什么时候会得到相应是不一定的。如果采用同步执行则向UI线程发送一个消息，然后一直等待，直到这个消息被相应后才接着向下执行。也就是说，在不跨线程的时候(在UI线程中操作控件)同步和异步是没有区别的，当然，不跨线程就可以直接操作控件了，没必要利用委托。

孙子曰：“兵者，国之大事，死生之地，存亡之道，不可不察也。”当代社会，应聘一个岗位，犹如与敌国打仗。准备打仗的时间与打仗时间之比应为10：1，甚至是100：1。故，我们不得不深究也。

最近，自己面试了上百个大学生，觉得他们在面试的心态和技能方面急需提高，以便顺利通过这一关，进入人生的第一个职业。面试过程中，我会向应聘者发问，而应聘者的回答将成为我考虑是否接受他的重要依据。对应聘者而言，了解这些问题背后的目的至关重要。

问题一：“请你自我介绍一下”

这个问题的面试方法是：应聘者站起来用五分钟的时间面对大家进行演讲。

我的目的是：了解应聘者的心理承受能力、逻辑思维能力、演讲能力，而他的生平介绍却是其次的，因为，我们在他的简历中已经对其有所了解。

应聘者应该做到：1、介绍内容要与个人简历相一致。 2、表述方式上尽量口语化。 3、要切中要害，不谈无关、无用的内容。 4、条理要清晰，层次要分明。5、要有训练有素的演讲语气和肢体语言，这是最重要的。

问题二：“你有什么业余爱好？”

我的目的是：了解应聘者的性格、观念、心态、思维的深度等。为了深入了解应聘者的爱好程度，我会提出更加深刻的问题，比如，应聘者喜欢流行音乐，我就会问相关的问题：“您什么时候开始喜欢的？您最喜欢哪个歌手？她的演唱风格如何？她的成名曲是哪一首？您最喜欢她的哪一首歌曲？为什么？”一个真正有这方面业余爱好的应聘者应该对答如流，遗憾的是，许多应聘者不能做到。

有的应聘者喜欢读书，我的相关问题就更加尖锐：“您最喜欢哪一位作家？您最喜欢这个作家的哪一本书？这本书的中心思想是什么？您阅读了这本书后有什么感悟？对人生的启示又是什么？”能够应答这类问题的应聘者寥寥无几。

应聘者应该做到：1、事先做好这方面的准备。2、 最好不要说自己没有业余爱好。 3、 不要说自己有那些庸俗的、令人感觉不好的爱好。

问题三：“谈谈你的缺点”

我的目的是：了解应聘者是否认真思考过自己，分析过自己，反省过自己。如果一个人能认清自己的缺点，并有改进的愿望和方法，他可能是一个不可多得的人才。

应聘者应该做到：1、 不宜说自己没有缺点，因为人一定有缺点的，除非是神。2、不宜说出严重影响所应聘工作的缺点。 3、对于自己真正的缺点，就认真对其进行剖析，并用积极的心态去面对，去修炼。

问题四：“举一个人生中最失败的经历”

我的目的是：了解应聘者的胆量和勇气，是否陷入了选择性知觉的陷阱，是否进行了深刻的反省，是否接受了深刻的教训。

应聘者应该做到： 1、 不宜说自己没有失败的经历。2、 宜说明失败之前自己曾信心白倍、尽心尽力。 3、 明确说明失败是主要由主观原因导致的。 4、 失败后自己曾做了深刻的反省，很快振作起来，以更加饱满的热情面对以后的学习或工作。

问题五：“你为什么选择我们公司？”

我的目的是：了解应聘者求职的动机、愿望以及对此项工作的态度。我十分欣赏对我公司很了解的应聘者。

应聘者应该做到：1、 建议从行业、企业和岗位这三个角度来回答。 2、 参考答案——“我十分看好贵公司所在的行业，我认为贵公司十分重视人才，而且这项工作很适合我，相信自己一定能做好。”

问题六：“对这项工作，你有哪些可预见的困难？”

我的目的是：应聘者的预测能力，并有应对方法。绝大多数的应聘者做不到。

应聘者应该做到： 1、 从技术、知识、经验等方面预见到的困难。2、说出自己对困难所持有的态度：“工作中出现一些困难是正常的，也是难免的，但是只要有坚忍不拔的毅力、勤奋的学习态度，良好的合作精神以及事前周密而充分的准备，任何困难都是可以克服的。”

问题七：“在工作中，与上级意见不一致，你将怎么办？”

我的目的是：了解应聘者的执行力，人际关系的沟通能力和协调能力，对工作的责任性。

应聘者应该做到： 1、首先给上级以必要的、私下的解释和提醒，在无效的情况下，又不会给公司造成重大损失，我会服从上级的意见。 2、 如果上级的决定会给公司造成重大损失，而我的解释和提醒无效时，我希望能向更高层领导反映。

问题八：“我们为什么要录用你？”

我的目的是：应聘者是否能够站在招聘单位的角度来回答，善解人意。

应聘者应该做到：1、企业会录用这样的应聘者：基本符合条件、对这份工作感兴趣、有足够的信心。 2、说出自己的观点：“我符合贵公司的招聘条件，凭我目前掌握的知识、技能、高度的责任感、良好的适应能力及学习能力，完全能胜任这份工作。我十分希望能为贵公司服务，如果贵公司给我这个机会，我一定能成为贵公司的栋梁！”

问题九：“你是应届毕业生，缺乏经验，如何能胜任这项工作？”

我的目的是：我并不真正在乎“经验”，关键是应聘者的心态，是否有克服自身困难的信心和决心，工作是否有责任性。

应聘者应该做到：1、 对这个问题的回答最好要体现出应聘者的诚恳、机智、果敢及敬业。 2、说出自己的观点：“作为应届毕业生，在工作经验方面的确会有所欠缺，因此在读书期间，我一直利用各种机会在这个行业里做兼职。我也发现，实际工作远比书本知识丰富、复杂。但我有较强的责任心、适应能力和学习能力，而且比较勤奋，所以在兼职中均能圆满完成各项工作，从中获取的经验也令我受益非浅。请贵公司放心，学校所学及兼职的工作经验使我一定能胜任这个职位。”

问题十：“你希望与什么样的上级共事？”

我的目的是：通过应聘者对上级的“希望”可以判断出应聘者对自我要求的意识，这既上一个陷阱，又上一次机会。

应聘者应该做到：1、最好回避对上级具体的希望，多谈对自己的要求。 2、 作为刚步入社会的新人，我应该多要求自己尽快熟悉环境、适应环境，而不应该对环境提出什么要求，只要能发挥我的专长就可以了。

问题十一：“您在前一家公司的离职原因是什么？”

我的目的是：应聘者是有感恩的心态，还是有仇恨的心态。特别鄙视那些应聘者，他们用极其不良的心态来贬低自己离职的公司。

应聘者应该做到：1、避免把“离职原因”说得太详细、太具体。2、 不能掺杂主观的负面感受，如“太幸苦”、“人际关系复杂”、“管理太混乱”、“公司不重视人才”、“公司排斥我们某某的员工”等。 3、但也不能躲闪、回避，如“想换换环境”、“个人原因”等。 4、不能涉及自己负面的人格特征，如不诚实、懒惰、缺乏责任感、不随和等。 5、尽量使解释的理由为应聘者个人形象添彩，如“我离职是因为这家公司倒闭。我在公司工作了三年多，有较深的感情。从去年始，由于市场形势突变，公司的局面急转直下。到眼下这一步我觉得很遗憾，但还是要面对的，所以，我想重新寻找能发挥我能力的舞台。”

同一个面试问题并非只有一个答案，而同一个答案并不是在任何面试场合都有效，关键在于应聘者掌握了规律后，对面试的具体情况进行把握，有意识地揣摩面试官提出问题的心理背景，然后投其所好。

最后，我要强调最重要的一点，就是应聘者的职业道德。有一个应聘故事很能说明问题。

小城中最大的一家外商独资企业招聘1名技术人员的消息不胫而走，该岗位的待遇是月工资5000元，工资奖金除外，每年还可以到大洋彼岸风光一次。所以，报考者蜂拥而至。

七月流火， 某厂的高工坐在闷罐似的考场里，蒸腾的暑气加上躁热的心情，热汗淋漓。但是，面对考题他并不怵，外文、专业技术类考题都答得十分圆满。惟有第二张考卷的两道怪题令他头疼： "您所在的企业或曾任职过的企业经营成功的诀窍是什么?技术秘密是什么?"

这类题对于曾在企业搞过技术的应考者并不难，可高工手中的笔却始终高悬着，捏来攥去，迟迟落不下去。多年的职业道德在约束着他：“厂里的数百名职工还在惨淡经营，我怎能为了自己的饭碗而砸大家的饭碗呢? ”他心中似翻江倒海，毅然挥笔在考卷上写下4个大字：“无可奉告。”

高工拖着沉重的步子向家里移动着，进门后，妻子一再追问，他才道出了答题的苦衷。全家人默默无语。

正当高工连日奔波，另谋职业之际，石破天惊，外商独资企业发来了录用通知。高工技压群雄，白卷夺冠，众议纷纷，成为小城一大新闻。

高工的职业道德多高啊！所谓职业道德，就是同人们的职业活动紧密联系的符合职业特点所要求的道德准则、道德情操与道德品质的总和，它既是对本职人员在职业活动中行为的要求，同时又是职业对社会所负的道德责任与义务。

为什么洁身自爱的人受人尊敬？因为他们不拿原则进行交易。透支职业道德就是拿原则做交易，这样的人和战场上的叛徒一样可怕，随时都会成为不安全隐患。因此，在你职业生涯中一定要时刻牢记：你要像保护你的生命一样遵守职业道德，永远不要犯原则性错误。
 

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/andylin02/archive/2009/10/26/4728891.aspx

2. 如何对DBCS(双字节字符集)字符串进行操作？
函数 描述
PTSTR CharNext ( LPCTSTR ); 返回字符串中下一个字符的地址
PTSTR CharPrev ( LPCTSTR, LPCTSTR )； 返回字符串中上一个字符的地址
BOOL IsDBCSLeadByte( BYTE )； 如果该字节是DBCS字符的第一个字节，则返回非0值

3. 为什么要使用Unicode？
(1) 可以很容易地在不同语言之间进行数据交换。
(2) 使你能够分配支持所有语言的单个二进制.exe文件或DLL文件。
(3) 提高应用程序的运行效率。
Windows 2000是使用Unicode从头进行开发的，如果调用任何一个Windows函数并给它传递一个ANSI字符串，那么系统首先要将字符串转换成Unicode，然后将Unicode字符串传递给操作系统。如果希望函数返回ANSI字符串，系统就会首先将Unicode字符串转换成ANSI字符串，然后将结果返回给你的应用程序。进行这些字符串的转换需要占用系统的时间和内存。通过从头开始用Unicode来开发应用程序，就能够使你的应用程序更加有效地运行。
Windows CE 本身就是使用Unicode的一种操作系统，完全不支持ANSI Windows函数
Windows 98 只支持ANSI，只能为ANSI开发应用程序。
Microsoft公司将COM从16位Windows转换成Win32时，公司决定需要字符串的所有COM接口方法都只能接受Unicode字符串。

4. 如何编写Unicode源代码？
Microsoft公司为Unicode设计了WindowsAPI，这样，可以尽量减少代码的影响。实际上，可以编写单个源代码文件，以便使用或者不使用Unicode来对它进行编译。只需要定义两个宏(UNICODE和_UNICODE)，就可以修改然后重新编译该源文件。
_UNICODE宏用于C运行期头文件，而UNICODE宏则用于Windows头文件。当编译源代码模块时，通常必须同时定义这两个宏。

5. Windows定义的Unicode数据类型有哪些？
数据类型 说明
WCHAR Unicode字符
PWSTR 指向Unicode字符串的指针
PCWSTR 指向一个恒定的Unicode字符串的指针
对应的ANSI数据类型为CHAR，LPSTR和LPCSTR。
ANSI/Unicode通用数据类型为TCHAR，PTSTR,LPCTSTR。

6. 如何对Unicode进行操作？
字符集 特性 实例
ANSI 操作函数以str开头 strcpy
Unicode 操作函数以wcs开头 wcscpy
MBCS 操作函数以_mbs开头 _mbscpy
ANSI/Unicode 操作函数以_tcs开头 _tcscpy(C运行期库)
ANSI/Unicode 操作函数以lstr开头 lstrcpy(Windows函数)
所有新的和未过时的函数在Windows2000中都同时拥有ANSI和Unicode两个版本。ANSI版本函数结尾以A表示；Unicode版本函数结尾以W表示。Windows会如下定义：
#ifdef UNICODE
#define CreateWindowEx CreateWindowExW
#else
#define CreateWindowEx CreateWindowExA
#endif // !UNICODE

7. 如何表示Unicode字符串常量？
字符集 实例
ANSI "string"
Unicode L"string"
ANSI/Unicode T("string")或_TEXT("string")if( szError[0] == _TEXT('J') ){}

8. 为什么应当尽量使用操作系统函数？
这将有助于稍稍提高应用程序的运行性能，因为操作系统字符串函数常常被大型应用程序比如操作系统的外壳进程Explorer.exe所使用。由于这些函数使用得很多，因此，在应用程序运行时，它们可能已经被装入RAM。
如：StrCat，StrChr，StrCmp和StrCpy等。

9. 如何编写符合ANSI和Unicode的应用程序？
(1) 将文本串视为字符数组，而不是chars数组或字节数组。
(2) 将通用数据类型(如TCHAR和PTSTR)用于文本字符和字符串。
(3) 将显式数据类型(如BYTE和PBYTE)用于字节、字节指针和数据缓存。
(4) 将TEXT宏用于原义字符和字符串。
(5) 执行全局性替换(例如用PTSTR替换PSTR)。
(6) 修改字符串运算问题。例如函数通常希望在字符中传递一个缓存的大小，而不是字节。这意味着不应该传递sizeof(szBuffer),而应该传递(sizeof(szBuffer)/sizeof(TCHAR)。另外，如果需要为字符串分配一个内存块，并且拥有该字符串中的字符数目，那么请记住要按字节来分配内存。这就是说，应该调用
malloc(nCharacters *sizeof(TCHAR)),而不是调用malloc(nCharacters)。

10. 如何对字符串进行有选择的比较？
通过调用CompareString来实现。
标志 含义
NORM_IGNORECASE 忽略字母的大小写
NORM_IGNOREKANATYPE 不区分平假名与片假名字符
NORM_IGNORENONSPACE 忽略无间隔字符
NORM_IGNORESYMBOLS 忽略符号
NORM_IGNOREWIDTH 不区分单字节字符与作为双字节字符的同一个字符
SORT_STRINGSORT 将标点符号作为普通符号来处理

11. 如何判断一个文本文件是ANSI还是Unicode？
判断如果文本文件的开头两个字节是0xFF和0xFE，那么就是Unicode，否则是ANSI。

12. 如何判断一段字符串是ANSI还是Unicode？
用IsTextUnicode进行判断。IsTextUnicode使用一系列统计方法和定性方法，以便猜测缓存的内容。由于这不是一种确切的科学方法，因此 IsTextUnicode有可能返回不正确的结果。

13. 如何在Unicode与ANSI之间转换字符串？
Windows函数MultiByteToWideChar用于将多字节字符串转换成宽字符串；函数WideCharToMultiByte将宽字符串转换成等价的多字节字符串。

二进制序列化
所谓二进制序列化，指的是对象序列化之后是二进制形式的。二进制序列化是通过BinaryFormatter类来实现的，这个类位于System.Runtime.Serialization.Formatters.Binary命名空间下。

XML序列化
所谓XML序列化，是指对象序列化之后的结果是XML形式的。保存XML序列化是通过XmlSerializer 类来实现的， 这个类位于System.Xml.Serialization命名空间下。

SOAP序列化
所谓SOAP序列化是指对象序列化之后的结果符合SOAP协议，也就是可以通过SOAP协议传输（不知道SOAP协议？百度一下吧）。SOAP序列化是通过SoapFormatter类来实现的，这个类位于System.Runtime.Serialization.Formatters.Soap命名空间下，并且需要注意需要手动添加对这个命名空间的引用，如下图所示：
 

下面编写一个类用于序列化和反序列化，这个类的代码如下：

using System;  
using System.Collections.Generic;  
using System.Text;  
 
namespace MySerializeDemo  
{  
    [Serializable]  
    /// <summary>  
    /// 要序列化的对象  
    /// 作者：周公  
    /// 编写时间：2009-03-10  
    /// </summary>  
    public class MyObject  
    {  
        //[NonSerialized]  
        private string name;  
        private DateTime birthday;  
        private string homePlace;  
        /// <summary>  
        /// 出生地  
        /// </summary>  
        public string HomePlace  
        {  
            get { return homePlace; }  
            set { homePlace = value; }  
        }  
   
        /// <summary>  
        /// 生日  
        /// </summary>  
        public DateTime Birthday  
        {  
            get { return birthday; }  
            set { birthday = value; }  
        }  
   
        /// <summary>  
        /// 姓名  
        /// </summary>  
        public string Name  
        {  
            get { return name; }  
            set { name = value; }  
        }  
   
        /// <summary>  
        /// 年龄  
        /// </summary>  
        public int Age  
        {  
            get { return DateTime.Now.Year - birthday.Year; }  
        }  
        /// <summary>  
        /// override了ToString()方法  
        /// </summary>  
        /// <returns></returns>  
        public override string ToString()  
        {  
            return string.Format("姓名：{0},生日：{1},出生地：{2},年龄：{3}",name,birthday,homePlace,Age);  
        }  
   
    }  
} 
using System;
using System.Collections.Generic;
using System.Text;

namespace MySerializeDemo
{
    [Serializable]
    /// <summary>
    /// 要序列化的对象
    /// 作者：周公
    /// 编写时间：2009-03-10
    /// </summary>
    public class MyObject
    {
        //[NonSerialized]
        private string name;
        private DateTime birthday;
        private string homePlace;
        /// <summary>
        /// 出生地
        /// </summary>
        public string HomePlace
        {
            get { return homePlace; }
            set { homePlace = value; }
        }
 
        /// <summary>
        /// 生日
        /// </summary>
        public DateTime Birthday
        {
            get { return birthday; }
            set { birthday = value; }
        }
 
        /// <summary>
        /// 姓名
        /// </summary>
        public string Name
        {
            get { return name; }
            set { name = value; }
        }
 
        /// <summary>
        /// 年龄
        /// </summary>
        public int Age
        {
            get { return DateTime.Now.Year - birthday.Year; }
        }
        /// <summary>
        /// override了ToString()方法
        /// </summary>
        /// <returns></returns>
        public override string ToString()
        {
            return string.Format("姓名：{0},生日：{1},出生地：{2},年龄：{3}",name,birthday,homePlace,Age);
        }
 
    }
}
下面是分别用上面的三个类进行序列化和反序列化的代码：

view plaincopy to clipboardprint?
using System;  
using System.Collections.Generic;  
using System.Text;  
using System.IO;  
using System.Runtime.Serialization.Formatters;  
using System.Runtime.Serialization.Formatters.Binary;  
using System.Runtime.Serialization.Formatters.Soap;  
using System.Xml.Serialization;  
 
namespace MySerializeDemo  
{  
    class Program  
    {  
        static void Main(string[] args)  
        {  
            MyObject obj = new MyObject();  
            obj.Birthday = new DateTime(1979, 11, 7);  
            obj.HomePlace = "湖北";  
            obj.Name = "周公";  
            Console.WriteLine("========使用BinaryFormatter类进行序列化和反序列化。====");  
            BinarySerialize(obj);  
            BinaryDeserialize("C:\\MyObject.dat");  
            Console.WriteLine("========使用SoapFormatter类进行序列化和反序列化。====");  
            SOAPSerialize(obj);  
            SOAPDeserialize("C:\\MyObject.soap");  
            Console.WriteLine("========使用XmlSerializer类进行序列化和反序列化。====");  
            XMLSerialize(obj);  
            XMLDeserialize("C:\\MyObject.xml");  
        }  
        /// <summary>  
        /// 二进制序列化对象  
        /// </summary>  
        /// <param name="obj"></param>  
        public static void BinarySerialize(MyObject obj)  
        {  
            using (FileStream stream = new FileStream("C:\\MyObject.dat", FileMode.Create, FileAccess.Write))  
            {  
                BinaryFormatter formater = new BinaryFormatter();  
                formater.Serialize(stream, obj);  
                Console.WriteLine("对象已经被序列化。" + obj.ToString());  
            }  
        }  
        /// <summary>  
        /// 二进制反序列化  
        /// </summary>  
        /// <param name="fileName"></param>  
        public static void BinaryDeserialize(string fileName)  
        {  
            using (FileStream stream = new FileStream(fileName, FileMode.Open, FileAccess.Read))  
            {  
                BinaryFormatter formater = new BinaryFormatter();  
                MyObject obj=(MyObject)formater.Deserialize(stream);  
                Console.WriteLine("对象已经被反序列化。" + obj.ToString());  
            }  
        }  
 
        /// <summary>  
        /// 二进制序列化对象  
        /// </summary>  
        /// <param name="obj"></param>  
        public static void SOAPSerialize(MyObject obj)  
        {  
            using (FileStream stream = new FileStream("C:\\MyObject.soap", FileMode.Create, FileAccess.Write))  
            {  
                SoapFormatter formater = new SoapFormatter();  
                formater.Serialize(stream, obj);  
                Console.WriteLine("对象已经被序列化。" + obj.ToString());  
            }  
        }  
        /// <summary>  
        /// 二进制反序列化  
        /// </summary>  
        /// <param name="fileName"></param>  
        public static void SOAPDeserialize(string fileName)  
        {  
            using (FileStream stream = new FileStream(fileName, FileMode.Open, FileAccess.Read))  
            {  
                SoapFormatter formater = new SoapFormatter();  
                MyObject obj = (MyObject)formater.Deserialize(stream);  
                Console.WriteLine("对象已经被反序列化。" + obj.ToString());  
            }  
        }  
        /// <summary>  
        /// XML序列化  
        /// </summary>  
        /// <param name="obj"></param>  
        public static void XMLSerialize(MyObject obj)  
        {  
            using (FileStream stream = new FileStream("C:\\MyObject.xml", FileMode.Create, FileAccess.Write))  
            {  
                XmlSerializer serializer = new XmlSerializer(typeof(MyObject));  
                serializer.Serialize(stream, obj);  
                Console.WriteLine("对象已经被序列化。" + obj.ToString());  
            }  
        }  
        /// <summary>  
        /// XML反序列化  
        /// </summary>  
        /// <param name="fileName"></param>  
        public static void XMLDeserialize(string fileName)  
        {  
            using (FileStream stream = new FileStream(fileName, FileMode.Open, FileAccess.Read))  
            {  
                XmlSerializer serializer = new XmlSerializer(typeof(MyObject));  
                MyObject obj = (MyObject)serializer.Deserialize(stream);  
                Console.WriteLine("对象已经被反序列化。" + obj.ToString());  
            }  
        }  
    }  
} 
using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.Runtime.Serialization.Formatters;
using System.Runtime.Serialization.Formatters.Binary;
using System.Runtime.Serialization.Formatters.Soap;
using System.Xml.Serialization;

namespace MySerializeDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            MyObject obj = new MyObject();
            obj.Birthday = new DateTime(1979, 11, 7);
            obj.HomePlace = "湖北";
            obj.Name = "周公";
            Console.WriteLine("========使用BinaryFormatter类进行序列化和反序列化。====");
            BinarySerialize(obj);
            BinaryDeserialize("C:\\MyObject.dat");
            Console.WriteLine("========使用SoapFormatter类进行序列化和反序列化。====");
            SOAPSerialize(obj);
            SOAPDeserialize("C:\\MyObject.soap");
            Console.WriteLine("========使用XmlSerializer类进行序列化和反序列化。====");
            XMLSerialize(obj);
            XMLDeserialize("C:\\MyObject.xml");
        }
        /// <summary>
        /// 二进制序列化对象
        /// </summary>
        /// <param name="obj"></param>
        public static void BinarySerialize(MyObject obj)
        {
            using (FileStream stream = new FileStream("C:\\MyObject.dat", FileMode.Create, FileAccess.Write))
            {
                BinaryFormatter formater = new BinaryFormatter();
                formater.Serialize(stream, obj);
                Console.WriteLine("对象已经被序列化。" + obj.ToString());
            }
        }
        /// <summary>
        /// 二进制反序列化
        /// </summary>
        /// <param name="fileName"></param>
        public static void BinaryDeserialize(string fileName)
        {
            using (FileStream stream = new FileStream(fileName, FileMode.Open, FileAccess.Read))
            {
                BinaryFormatter formater = new BinaryFormatter();
                MyObject obj=(MyObject)formater.Deserialize(stream);
                Console.WriteLine("对象已经被反序列化。" + obj.ToString());
            }
        }

        /// <summary>
        /// 二进制序列化对象
        /// </summary>
        /// <param name="obj"></param>
        public static void SOAPSerialize(MyObject obj)
        {
            using (FileStream stream = new FileStream("C:\\MyObject.soap", FileMode.Create, FileAccess.Write))
            {
                SoapFormatter formater = new SoapFormatter();
                formater.Serialize(stream, obj);
                Console.WriteLine("对象已经被序列化。" + obj.ToString());
            }
        }
        /// <summary>
        /// 二进制反序列化
        /// </summary>
        /// <param name="fileName"></param>
        public static void SOAPDeserialize(string fileName)
        {
            using (FileStream stream = new FileStream(fileName, FileMode.Open, FileAccess.Read))
            {
                SoapFormatter formater = new SoapFormatter();
                MyObject obj = (MyObject)formater.Deserialize(stream);
                Console.WriteLine("对象已经被反序列化。" + obj.ToString());
            }
        }
        /// <summary>
        /// XML序列化
        /// </summary>
        /// <param name="obj"></param>
        public static void XMLSerialize(MyObject obj)
        {
            using (FileStream stream = new FileStream("C:\\MyObject.xml", FileMode.Create, FileAccess.Write))
            {
                XmlSerializer serializer = new XmlSerializer(typeof(MyObject));
                serializer.Serialize(stream, obj);
                Console.WriteLine("对象已经被序列化。" + obj.ToString());
            }
        }
        /// <summary>
        /// XML反序列化
        /// </summary>
        /// <param name="fileName"></param>
        public static void XMLDeserialize(string fileName)
        {
            using (FileStream stream = new FileStream(fileName, FileMode.Open, FileAccess.Read))
            {
                XmlSerializer serializer = new XmlSerializer(typeof(MyObject));
                MyObject obj = (MyObject)serializer.Deserialize(stream);
                Console.WriteLine("对象已经被反序列化。" + obj.ToString());
            }
        }
    }
}
这个程序的运行效果如下：
 
可见通过上面三个类都能实现将对象序列化保存，并且都能反序列化还原到对象被序列化之前的状态（这正是序列化意义所在，能保存对象运行时的状态并且还能还原）。如果运行上面的代码会在C盘根目录下创建三个文件，分别是MyObject.dat、MyObject.soap和MyObject.xml文件，因为MyObject.dat是二进制文件，所以无法查看文件的内容，但是我们可以打开MyObject.soap和MyObject.xml这两个文件来比较一下有什么区别。
MyObject.soap文件的后缀虽然是.soap，但是还是可以用记事本打开的，下面是MyObject.soap文件的内容：
view plaincopy to clipboardprint?
<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:SOAP-ENC="http://schemas.xmlsoap.org/soap/encoding/" xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" xmlns:clr="http://schemas.microsoft.com/soap/encoding/clr/1.0" SOAP-ENV:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"> 
<SOAP-ENV:Body> 
<a1:MyObject id="ref-1" xmlns:a1="http://schemas.microsoft.com/clr/nsassem/MySerializeDemo/MySerializeDemo%2C%20Version%3D1.0.0.0%2C%20Culture%3Dneutral%2C%20PublicKeyToken%3Dnull"> 
<name id="ref-3">周公</name> 
<birthday>1979-11-07T00:00:00.0000000+08:00</birthday> 
<homePlace id="ref-4">湖北</homePlace> 
</a1:MyObject> 
</SOAP-ENV:Body> 
</SOAP-ENV:Envelope> 
<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:SOAP-ENC="http://schemas.xmlsoap.org/soap/encoding/" xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" xmlns:clr="http://schemas.microsoft.com/soap/encoding/clr/1.0" SOAP-ENV:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
<SOAP-ENV:Body>
<a1:MyObject id="ref-1" xmlns:a1="http://schemas.microsoft.com/clr/nsassem/MySerializeDemo/MySerializeDemo%2C%20Version%3D1.0.0.0%2C%20Culture%3Dneutral%2C%20PublicKeyToken%3Dnull">
<name id="ref-3">周公</name>
<birthday>1979-11-07T00:00:00.0000000+08:00</birthday>
<homePlace id="ref-4">湖北</homePlace>
</a1:MyObject>
</SOAP-ENV:Body>
</SOAP-ENV:Envelope>
MyObject.xml文件也可以用记事本打开，它的内容如下：

view plaincopy to clipboardprint?
<?xml version="1.0"?> 
<MyObject xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 
  <HomePlace>湖北</HomePlace> 
  <Birthday>1979-11-07T00:00:00</Birthday> 
  <Name>周公</Name> 
</MyObject> 
<?xml version="1.0"?>
<MyObject xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <HomePlace>湖北</HomePlace>
  <Birthday>1979-11-07T00:00:00</Birthday>
  <Name>周公</Name>
</MyObject>
熟悉SOAP协议的朋友一看MyObject.soap文件的内容就知道它符合SOAP协议，MyObject.xml文件毫无疑问是一个符合XML规范的文件。

对代码作几点说明：
1、如果采用BinaryFormatter类或者SoapFormatter类来实现序列化，则一定要给类加上Serializable属性，如代码中所示：
view plaincopy to clipboardprint?
[Serializable]  
    /// <summary>  
    /// 要序列化的对象  
    /// 作者：周公  
    /// 编写时间：2009-03-10  
    /// </summary>  
    public class MyObject 
[Serializable]
    /// <summary>
    /// 要序列化的对象
    /// 作者：周公
    /// 编写时间：2009-03-10
    /// </summary>
    public class MyObject
如果不给要序列化的对象加上这个属性，那么采用采用BinaryFormatter类或者SoapFormatter类来实现序列化时会报异常，但使用XmlSerializer 类序列化对象时可以不用这个属性。
2、另外，如果不想序列化某个字段，可以给其加上NonSerialized属性，这样在序列化时就不会保存这个这个字段的值了，比如不想序列化name这个字段，可以如下写代码：

view plaincopy to clipboardprint?
…//其它代码  
//[NonSerialized]  
private string name;  
…//其它代码 
…//其它代码
//[NonSerialized]
private string name;
…//其它代码
再次运行刚才的程序会得到如下效果：
 
看有黄色底线部分，因为name字段不被序列化，所以通过二进制序列化和SOAP序列化之后再反序化就得不到原来的值了。
3、最后还需要说明一点的是，SoapFormatter类在.net3.5开始已经过时了，微软建议使用BinaryFormatter类来序列化和反序列化了。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/zhoufoxcn/archive/2009/03/11/3978874.aspx

   private Point m_MousePoint;
private Point m_LastPoint;

  protected override void OnMouseDown(MouseEventArgs e)
{
base.OnMouseDown(e);
this.m_LastPoint = this.Location;
this.m_MousePoint = this.PointToScreen(e.Location);
}

protected override void OnMouseMove(MouseEventArgs e)
{
base.OnMouseMove(e);
if (e.Button == MouseButtons.Left)
{
Point t = this.PointToScreen(e.Location);
Point l = this.m_LastPoint;

        l.Offset(t.X - this.m_MousePoint.X, t.Y - this.m_MousePoint.Y);
this.Location = l;
}
}

1 代码直接复制到窗体上就可以使用.

2 可以用到UserControl上,UserControl就成了一个可拖动的控件了

3 可以用到自定义控件上,例如:自定义控件继承了一个Button ,然后写上上面代码,那么这个自定义Button就可以在Form窗体上随处拖动....

 方法二: 不规则窗体拖动

using System.Runtime.InteropServices;

[DllImport("user32.dll")]
public static extern bool ReleaseCapture();
[DllImport("user32.dll")]
public static extern bool SendMessage(IntPtr hwnd, int wMsg, int wParam, int lParam);
public const int WM_SYSCOMMAND = 0x0112;
public const int SC_MOVE = 0xF010;
public const int HTCAPTION = 0x0002;

public void ShapedForm_MouseDown(object sender, MouseEventArgs e)
{
ReleaseCapture();
SendMessage(this.Handle, WM_SYSCOMMAND, SC_MOVE + HTCAPTION, 0);
}

方法二:比较好 ,能够画出 虚线框,跟Windows的窗体拖动一样...........