基本使用方式

　 　反射是.NET中非常重要的功能。使用反射来构造对象、调用方法或是访问属性是某些项目中常用的做法之一（例如ORM框架）。众所周知，与一个成员的直 接访问相比，反射调用的性能要低好几个数量级。FastReflectionLib提供了一种简便的方式，使一些常用反射调用的性能得到大幅提高。如下：

using System;
using System.Reflection;
using FastReflectionLib;

namespace SimpleConsole
{
class Program
{
static void Main(string[] args)
        {
PropertyInfo propertyInfo = typeof(string).GetProperty("Length");
MethodInfo methodInfo = typeof(string).GetMethod("Contains");

string s = "Hello World!";

// get value by normal reflection
int length1 = (int)propertyInfo.GetValue(s, null);
// get value by the extension method from FastReflectionLib,
            // which is much faster
int length2 = (int)propertyInfo.FastGetValue(s);

// invoke by normal reflection
bool result1 = (bool)methodInfo.Invoke(s, new object[] { "Hello" });
// invoke by the extension method from FastReflectionLib,
            // which is much faster
bool result2 = (bool)methodInfo.FastInvoke(s, new object[] { "Hello" });
        }
    }
}

　　在得到了PropertyInfo或MethodInfo对象之后，我们可以使用GetValue或Invoke方法来访问属性或调用方法。在 FastReflectionLib中为PropertyInfo、MethodInfo等对象定义了对应的扩展方法，于是我们就可以使用这些扩展方法 （从代码上看来，基本上只是在原来的方法之前加上“Fast”）来进行调用，与之前的方法相比，新的扩展方法性能有极大的提高。

直接使用各工作对象

　　各FastXxx方法实际上是将PropertyInfo等对象作为Key去一个Cache中获取对应的工作对象，然后调用工作对象上对应的方法。因此，直接调用工作对象可以获得更好的性能。各工作对象类型的对应关系如下：

• PropertyInfo：IPropertyAccessor
• MethodInfo：IMethodInvoker
• ConstructorInfo：IConstructorInvoker
• FieldInfo：IFieldAccessor

　　我们可以使用FastReflectionCaches.MethodInvokerCache来获取一个IMethodInvoker对象：

static void Execute(MethodInfo methodInfo, object instance, int times)
{ 
IMethodInvoker invoker = FastReflectionCaches.MethodInvokerCache.Get(methodInfo);
object[] parameters = new object[0];
for (int i = 0; i < times; i++)
    {
        invoker.Invoke(instance, parameters);
    }
}

工作对象的默认实现与扩展

　　在FastReflectionLib中，已经提供了IPropertyAccessor等接口的默认实现。该实现将会构造一颗表达式树 （Expression Tree）并将其编译（调用其Compile方法）以获得一个与反射方法签名相同的委托对象。这是一种简单、通用而安全的实现，由于Compile方法使 用了Emit，其性能也较为令人满意（可见下面的性能测试）。但是这并不是性能最高的做法，如果使用Emit生成最优化的代码，其性能甚至会高于方法的直 接调用（例如Dynamic Reflection Library）。如果您想使用更好的实现来替换，则可以自行构造一个工作对象接口的实现，并替换对应的Factory：

public class BetterPropertyAccessor : IPropertyAccessor
{
public BetterPropertyAccessor(PropertyInfo propertyInfo) { ... }

    ...
}

public class BetterPropertyAccessorFactory :
IFastReflectionFactory<PropertyInfo, IPropertyAccessor>
{
public IPropertyAccessor Create(PropertyInfo key)
    {
return new BetterPropertyAccessor(key);
    }
}

class Program
{
static void Main(string[] args)
    {
FastReflectionFactories.PropertyAccessorFactory =
new BetterPropertyAccessorFactory();

        ...
    }
}

缓存的默认实现与扩展

　　在FastReflectionLib中使用基于 System.Collections.Generic.Dictionary<TKey, TValue>类型编写的缓存容器。每次调用FastXxx扩展方法时，类库将从对应的缓存容器中获取工作对象。如果缓存容器中还没有所需的工作对 象，那么它就会调用合适的Factory来构造新的工作对象。从下面的性能测试来看，许多时间是消耗在缓存查找上的，如果您有更好的缓存实现，可以使用以 下的方法替换默认的缓存的容器：

public class BetterMethodInvokerCache :
IFastReflectionCache<MethodInfo, IMethodInvoker>
{
public IMethodInvoker Get(MethodInfo key) { ... }
}

class Program
{
static void Main(string[] args)
    {
FastReflectionCaches.MethodInvokerCache = 
new BetterMethodInvokerCache();

        ...
    }
}

根据需要自行缓存工作对象

　　FastReflectionLib中通过PropertyInfo等对象作为Key，对PropertyAccessor等工作对象进行缓 存。但是在某些场景下，您也可以选择合适的方式来自行缓存工作对象。与FastReflectionLib源码同时发布的CustomCache示例网站 中包含了一个FastEval扩展，在某些场景下，我们可以使用这个更高效的方法来替换内置的Eval方法。这个示例的特点如下：

• 使用对象的类型和属性名同时作为缓存的Key获取对应的PropertyAccessor对象
• 使用PropertyAccessor获取“匿名对象”中的属性值
• 缓存的作用域为特定页面，而不是整个AppDomain。

性能测试

　　FastReflectionLib源码中包含了一个性能测试项目，您可以从中看出FastReflectionLib对于反射的性能改进。摘录部分数据如下（测试在我的笔记本上运行，Release编译）。

　　执行以下方法：

public class Test
{
public void MethodWithArgs(int a1, string a2) { }
}

　　进行一百万次调用，结果如下：

///<summary>
///得到随机字符.
///</summary>
///<param name="intLength">Length of the int.</param>
///<param name="booNumber">if set to <c>true</c> [boo number].</param>
///<param name="booSign">if set to <c>true</c> [boo sign].</param>
///<param name="booSmallword">if set to <c>true</c> [boo smallword].</param>
///<param name="booBigword">if set to <c>true</c> [boo bigword].</param>
///<returns></returns>
public string getRandomizer(int intLength, bool booNumber, bool booSign, bool booSmallword, bool booBigword)
{
 //定义
 Random ranA = new Random();
 int intResultRound = 0;
 int intA = 0;
 string strB = "";
 while (intResultRound < intLength)
 {
  //生成随机数A，表示生成类型
  //1=数字，2=符号，3=小写字母，4=大写字母
  intA = ranA.Next(1, 5);
  //如果随机数A=1，则运行生成数字
  //生成随机数A，范围在0-10
  //把随机数A，转成字符
  //生成完，位数+1，字符串累加，结束本次循环
  if (intA == 1 && booNumber)
  {
   intA = ranA.Next(0, 10);
   strB = intA.ToString() + strB;
   intResultRound = intResultRound + 1;
   continue;
  }
  //如果随机数A=2，则运行生成符号
  //生成随机数A，表示生成值域
  //1：33-47值域，2：58-64值域，3：91-96值域，4：123-126值域
  if (intA == 2 && booSign == true)
  {
   intA = ranA.Next(1, 5);
   //如果A=1
   //生成随机数A，33-47的Ascii码
   //把随机数A，转成字符
   //生成完，位数+1，字符串累加，结束本次循环
   if (intA == 1)
   {
    intA = ranA.Next(33, 48);
    strB = ((char)intA).ToString() + strB;
    intResultRound = intResultRound + 1;
    continue;
   }

   //如果A=2
   //生成随机数A，58-64的Ascii码
   //把随机数A，转成字符
   //生成完，位数+1，字符串累加，结束本次循环
   if (intA == 2)
   {
    intA = ranA.Next(58, 65);
    strB = ((char)intA).ToString() + strB;
    intResultRound = intResultRound + 1;
    continue;
   }

   //如果A=3
   //生成随机数A，91-96的Ascii码
   //把随机数A，转成字符
   //生成完，位数+1，字符串累加，结束本次循环
   if (intA == 3)
   {
    intA = ranA.Next(91, 97);
    strB = ((char)intA).ToString() + strB;
    intResultRound = intResultRound + 1;
    continue;
   }

   //如果A=4
   //生成随机数A，123-126的Ascii码
   //把随机数A，转成字符
   //生成完，位数+1，字符串累加，结束本次循环
   if (intA == 4)
   {
    intA = ranA.Next(123, 127);
    strB = ((char)intA).ToString() + strB;
    intResultRound = intResultRound + 1;
    continue;
   }
  }

  //如果随机数A=3，则运行生成小写字母
  //生成随机数A，范围在97-122
  //把随机数A，转成字符
  //生成完，位数+1，字符串累加，结束本次循环
  if (intA == 3 && booSmallword == true)
  {
   intA = ranA.Next(97, 123);
   strB = ((char)intA).ToString() + strB;
   intResultRound = intResultRound + 1;
   continue;
  }

  //如果随机数A=4，则运行生成大写字母
  //生成随机数A，范围在65-90
  //把随机数A，转成字符
  //生成完，位数+1，字符串累加，结束本次循环
  if (intA == 4 && booBigword == true)
  {
   intA = ranA.Next(65, 89);
   strB = ((char)intA).ToString() + strB;
   intResultRound = intResultRound + 1;
   continue;
  }
 }
 return strB;
}

//随机字符串生成器的主要功能如下：
//1、支持自定义字符串长度
//2、支持自定义是否包含数字
//3、支持自定义是否包含小写字母
//4、支持自定义是否包含大写字母
//5、支持自定义是否包含特殊符号
//6、支持自定义字符集

///<summary>
///生成随机字符串
///</summary>
///<param name="length">目标字符串的长度</param>
///<param name="useNum">是否包含数字，1=包含，默认为包含</param>
///<param name="useLow">是否包含小写字母，1=包含，默认为包含</param>
///<param name="useUpp">是否包含大写字母，1=包含，默认为包含</param>
///<param name="useSpe">是否包含特殊字符，1=包含，默认为不包含</param>
///<param name="custom">要包含的自定义字符，直接输入要包含的字符列表</param>
///<returns>指定长度的随机字符串</returns>
public string GetRnd(int length, bool useNum, bool useLow, bool useUpp, bool useSpe, string custom)
{
 byte[] b = new byte[4];
 new System.Security.Cryptography.RNGCryptoServiceProvider().GetBytes(b);
 Random r = new Random(BitConverter.ToInt32(b, 0));
 string s = null, str = custom;
 if (useNum == true) { str += "0123456789"; }
 if (useLow == true) { str += "abcdefghijklmnopqrstuvwxyz"; }
 if (useUpp == true) { str += "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; }
 if (useSpe == true) { str += "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~"; }
 for (int i = 0; i < length; i++)
 {
  s += str.Substring(r.Next(0, str.Length - 1), 1);
 }
 return s;
}

1、 msftpsrvr.exe（服务器端）

由coreftp开发的迷你sftp服务软件，无需任何安装。

网址：http://www.coreftp.com/server/index.html

2、 psftp.exe（客户端）

PSFTP是PuTTY SFTP客户端，用于本地与服务器间安全传输文件（使用SSH连接）。

网址：http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html

3、 创建Window Service（服务器端）
使用C#语言、Visual Studio 开发工具，创建Window Service，用于管理msftpsrvr.exe在服务器的启动状况。
以服务开启msftpsrvr.exe进程，可以实现系统启动时启动、避免登录用户注销导致进程关闭。

二、具体创建

1、服务器配置msftpsrvr.exe

msftpsrvr.exe的界面如下所示：

其中Root为sftp存储文件设置根目录文件夹，点击Start後程式就会侦听客户端的链接。Connections的列表可以查看当前客户端正在连接的状态。Port推荐为22，其他端口的话会可能被防火墙挡住。

填写的所有信息（即User, Password, Port, Root）会以当前登录用户，贮存在注册表中。因此由不同用户登录操作系统的话，此sftp的信息都会分别存储。

现在的目标是用Window Service（服务）启动此程序，出现2个问题：

1)                  启动服务是以System用户启动，因此进程msftpsrvr.exe归属于System用户，进程打开后是没有任何UI显示的。因此sftp所需要的信息（即User, Password, Port, Root）就无法设置。

2)                  启动进程，但还需要点击“Start”的按钮。在没有UI的情况怎么令msftpsrvr.exe自动进入Start状态。

解决方案：

1)      msftpsrvr.exe保存的信息都在注册表中，如果是当前登录用户，储存的路径就是HKEY_CURRENT_USER\Software\FTPWare。
如下图所示：

       类似的，可以在注册表的用户默认设置，添加sftp的信息。路径为

       HKEY_USERS\.DEFAULT\Software\FTPWare

       在这里模仿添加上图中的Path、Port、PW、User的数值。

       这样，以其他任何用户初始打开sftp的时候，都会有我们所设置的默认值，当然包括启动服务的System用户。

2)      启动msftpsrvr.exe时，添加 –start 命令参数即可。

2、使用psftp.exe

       点击打开psftp.exe，出现如下图的命令窗口。

       输入open [user]@[host]，user为用户名，host为sftp服务器的ip，如输入

open aaa@172.18.235.56

回车后出现以下提示

输入n，不需要把key缓存；然后提示输入密码。成功连接后，就会返回命令符。

输入put [FilePath] 就可以把文件传到sftp的文件夹中。如输入

put “D:\temp\temp\sftp架设方案.doc”

上传文件到sftp成功。

以上是命令行操作psftp。如需要像批处理文件，直接执行任务。可利用psftp的命令参数。如下所示：

"psftp.exe" aaa@127.0.0.1 -pw aaa -b "aaa.txt" -bc

解释：

1)      aaa@127.0.0.1：要直接连接目标sftp服务器，aaa为用户名，127.0.0.1为服务器ip。

2)      –pw aaa：设置密码为aaa。

3)      -b "aaa.txt" ：指定需要操作的命令文本。
具体aaa.txt的文本内容，如下所示：
put "FBMS前台宣导材料再稿.ppt"

4)      –bc：输出执行过的命令语句。

这样的话，可以直接执行"psftp.exe" aaa@127.0.0.1 -pw aaa -b "aaa.txt" –bc可以顺利连接服务器并执行指定任务。

C#执行的时候就可以拼凑命令字符串，然后直接执行。

Psftp参数和命令参考

Usage: psftp [options] [user@]host

Options:	描述
-V	print version information and exit（打印版本）
-pgpfp	print PGP key fingerprints and exit
-b file	use specified batchfile（读取格式化文件，按照文件格式执行命令，及预先要交互的命令都放到这个文件里）
-bc	output batchfile commands （输出执行过的命令语句）
-be	don't stop batchfile processing if errors（遇错跳过）
-v	show verbose messages （详细回显）
-load sessname	Load settings from saved session （使用预先保存好的sessname，保存在HKEY_CURRENT_USER\Software\SimonTatham\PuTTY\Sessions）
-l user	connect with specified username （用户名）
-P port	connect to specified port （端口）
-pw passw	login with specified password （密码）
-1 -2	force use of particular SSH protocol version （使用ssh协议）
-4 -6	force use of IPv4 or IPv6 （支持ipv4 或ipv6）
-C	enable compression （支持压缩格式，节省带宽）
-i key	private key file for authentication
-noagent	disable use of Pageant
-agent	enable use of Pageant
-batch	disable all interactive prompts 不允许交互命令

psftp命令：

命令	描述
bye	结束 psftp 。
cd	改变远程服务器的目录。
chmod	改变远程服务器的文件或文件夹的权限及属性。
del	删除远程服务器上的文件。
dir	列出远程服务器上的所有文件和目录。
exit	结束 psftp 。
get	从远程服务器上下载指定文件。
help	使用帮助。
lcd	改变本地计算机的工作目录。
lpwd	显示本地计算机工作目录。
ls	列出远程服务器上的所有文件和目录。
mkdir	在远程服务器上建立一个目录。
mv	移动远程服务器上的文件或者改名。
open	连接指定的远程服务器。
put	把本地的文件上传到远程服务器上。
pwd	移动远程服务器上的文件或者改名。
quit	结束 psftp 。
reget	断点下载未完的指定文件。
ren	移动远程服务器上的文件或者改名。
reput	断点上传未完的指定文件。
rm	刪除远程服务器上的一个文件。
rmdir	刪除远程服务器上的一个目录。

3、开发window service

       Window Service的作用在于Window Service可以以System的用户启动进程，System用户是不会注销的，因此其他登录用户注销时，可以避免以服务开启的进程关闭。

       Visual Studio开发Window服务，先新建“Windows 服务”项目。

       在Service1.cs中编写服务启动代码：

       显示Services1的设计界面，点击右键选择“添加安装程序”。在项目就会自动生成ProjectInstaller.cs。用于配置Window服务的基本信息。

       注意选择serviceProcessInstaller的时候，Accout要需要选择LocalSystem，这样服务才会以System用户启动。

       编译后，需要用.net framework的命令符把服务注册到操作系统中。如下选择Visual Studio 命令提示。

       在命令行输入如下指令，即可成功把服务应用程序安装到操作系统。

InstallUtil "D:\temp\WindowsService1\bin\Debug\WindowsService1.exe"

三、 其他改进

1、 msftpsrvr.exe的注册表设置可以到处一个reg文件，方便导入注册表。

2、 Window Service可以设置一个定时器，每隔一段时间查看进程是否在启动中，如果没有则开启。

3、 Window Service提供输入参数的设置，可以灵活配置Window Service所要启动的应用程序。

     JIT Compilation and Performance - To NGen or Not to NGen?

     文中的观点是应该在大多数程序中避免使用ngen预编译IL代码为Native代码，因为JIT编译器可能比ngen更了解用户的系统。例如JIT编译器有以下优势：

     1.可以知道用户正在使用的什么类型的CPU，是PII、PIII还是P4，并编译生成相应的优化指令
     2.可以知道用户当前是使用单CPU还是多CPU，以便优化线程锁定机制
     3.可以避免ngen静态编译带来的DLL载入时重定位问题等等

     而且使用ngen预编译代码还会带来一些潜在的问题：

     1.没有知识产权保护：与某些人预期的不同，ngen生成的Native代码不能独立发布。因为其中没有包含Metadata信息，所以还是必须与原始的IL代码一同发布
     2.ngen生成的文件可能不同步：CLR在载入ngen生成的文件时，要检测其编译时的属性是否与当前环境匹配，不匹配则使用缺省的JIT编译
     3.难以管理：ngen生成的文件不能自动删除，因此违背了.NET架构程序的XCOPY分发策略
     4.低劣的载入时性能(重定位)：如果ngen生成的DLL文件的基址已经被占用，则载入时需要重定位(rebase)
     5.低劣的运行时性能：ngen生成的文件采用较为保守的假定环境，因此代码效率低于JIT编译
     6. 某些应用程序域(domain)的载入策略会忽略ngen生成的文件：assembly可以以应用程序域相关(non-domain-neutral)和 无关(domain-neutral)的方式被载入，但ngen生成的文件假设只有mscorlib.dll以应用程序域无关的方式被载入。因此当某个 assembly通过应用程序域无关的方式被使用，则ngen生成的代码无法使用，还是要通过JIT编译。例如ASP.NET中所有具有 strongly-named的assembly都会被通过应用程序域无关的方式载入。

     因此Jeffrey Richter认为，只有对于客户端程序能够有可测量的载入性能提升的情况下，才应该使用ngen预编译代码，而对于其他程序，特别是服务器端程序，都应该避免ngen的使用。
     
     不过CLR组的Junfeng Zhang并不十分赞同上述观点，故而在其BLog上发表了一篇批驳的文章
     
     JIT Compilation and Performance - To NGen or Not to NGen? 
     
     文中对Jeffrey Richter提出的ngen的几个潜在问题逐条反驳：

     1.ngen并不是用来保护知识产权的工具，只是优化载入时性能而已，可以通过其他工具如混淆器(obfuscator)保护知识产权
     2.一般只有在维护.NET Framework和自己的程序后，才会导致不同步问题，而此时可以使用ngen重新生成预编译文件
     3.ngen支持 /delete 命令行参数，因此可以通过写一个批处理文件完成自动删除
     4.重定位是所有dll都存在的问题，并不能为了避免重定位就不使用dll而采用巨大的exe文件，因此这不能作为不使用ngen的理由。而且CLR载入dll的时候会检测这种情况的发生，并在合适的情况下拒绝使用ngen生成的文件
     5.CLR 目前的JIT编译器对所有代码只编译一次，而不是象Sun的Hotspot那样，监视已JIT的代码，根据动态行为重新JIT优化性能。而ngen具有的 JIT无法达到的优势是可以跨assembly做一些代码的优化。不过ngen代码还是比JIT编译平均有5%-10%的性能损失，单能大大提高载入速 度。
     6.ngen编译的文件的确在某些情况下无法被使用，但这并不能作为不使用ngen的理由
     
     此外ngen还有个优点是其生成的代码可以被多个进程共享，而JIT编译生成的代码在私有地址空间中。
     
     因此ngen在客户端代码的处理上还是有价值的，呵呵
     
     后面MS的Josh Williams又补充说，在64位版本的.NET中，ngen生成代码的性能可能比JIT代码有较大改善，因为ngen包含了一些对JIT来说过于复杂的全局优化措施。
     
     最后Junfeng Zhang还给出了一个性能优化的指导性文章的链接
     
     Profile-Guided Optimization with Microsoft Visual C++ 2005
     
     有趣的讨论，通过这种BLog的论战，很容易就能够获得一些通过正规渠道文章无法了解的内幕消息，呵呵

[STAThread]
STAThread：Single     Thread     Apartment Thread.(单一线程单元线程)
[]是用来表示Attributes；

[STAThread]
是一种线程模型，用在程序的入口方法上（在C#和VB.NET里是Main()方法），来指定当前线程的ApartmentState 是STA。用在其他方法上不产生影响。在aspx页面上可以使用 AspCompat = "true" 来达到同样的效果。这个属性只在  Com  Interop  有用，如果全部是  managed  code  则无用。简单的说法:[STAThread]指示应用程序的默认线程模型是单线程单元 (STA)。启动线程模型可设置为单线程单元或多线程单元。如果未对其进行设置，则该线程不被初始化。也就是说如果你用的.NET Framework，并且没有使用COM Interop，一般不需要这个Attribute。其它的还有MTA（多线程套间）、Free  Thread（自由线程）。

[STAThread] attribute指示应用程序的 COM 线程模型是单线程单元。
而于此对应的多线程单元则是 [MTAThread] （多线程单元线程）

COM 线程模型只适用于使用 COM interop 的应用程序。如果将此属性应用到不使用 COM interop 的应用程序，将没有任何效果。

COM 线程模型可设置为单线程单元或多线程单元。如果应用程序线程实际调用了 COM 组件，则仅为 COM interop 初始化该线程。如果没有使用 COM interop，则不初始化该线程。

以下是找到的一个资料介绍：
Q. When I create a c# project from scratch in VS.NET, the generated code always have a [STAThread] attribute above the main routine. What does the STAThread attribute really do? Can I change it to MTAThread instead? I have searched website and books, no one seems to explain this well.

Asked by anon. Answered by the Wonk on February 17, 2003

A.

The STAThreadAttribute marks a thread to use the Single-Threaded COM Apartment if COM is needed. By default, .NET won't initialize COM at all. It's only when COM is needed, like when a COM object or COM Control is created or when drag 'n' drop is needed, that COM is initialized. When that happens, .NET calls the underlying CoInitializeEx function, which takes a flag indicating whether to join the thread to a multi-threaded or single-threaded apartment.

A multi-threaded apartment (MTA) in COM is more efficient, since any of a number of RPC threads from a pool can be used to handle a request. However, an object on the MTA thread needs to protect itself from multiple threads accessing it at the same time, so that efficiency comes at a cost.

The single-thread apartment (STA) in COM is inherently single-threaded and therefore no additional thread synchronization is needed. The STA is implemented using the thread's Windows message queue, which is how requests to objects on an STA are serialized. Because of how the STA thread is implemented, calls to objects on that thread are serialized with Windows message handling on that thread, making sure that everything, both the COM objects and the underlying windowing objects, e.g. HWNDs, are all synchronized. This is necessary for UI-oriented COM objects, like controls and drag 'n' drop, which must also be synchronized together with the UI.

当一个程序开始运行时，它就是一个进程，进程包括运行中的程序和程序所使用到的内存和系统资源。
而一个进程又是由多个线程所组成的。

什么是线程？
线程是程序中的一个执行流，每个线程都有自己的专有寄存器(栈指针、程序计数器等)，但代码区是共享的，即不同的线程可以执行同样的函数。

什么是多线程？
多线程是指程序中包含多个执行流，即在一个程序中可以同时运行多个不同的线程来执行不同的任务，也就是说允许单个程序创建多个并行执行的线程来完成各自的任务。

多线程的好处：
可以提高CPU的利用率。在多线程程序中，一个线程必须等待的时候，CPU可以运行其它的线程而不是等待，这样就大大提高了程序的效率。

多线程的不利方面：
线程也是程序，所以线程需要占用内存，线程越多占用内存也越多；
多线程需要协调和管理，所以需要CPU时间跟踪线程；
线程之间对共享资源的访问会相互影响，必须解决竞用共享资源的问题；
线程太多会导致控制太复杂，最终可能造成很多Bug；

接下来将对C#编程中的多线程机制进行探讨。为了省去创建GUI那些繁琐的步骤，更清晰地逼近线程的本质，接下来的所有程序都是控制台程序，程序最后的Console.ReadLine()是为了使程序中途停下来，以便看清楚执行过程中的输出。

任何程序在执行时，至少有一个主线程。

一个直观印象的线程示例：

输出如下：
System Thread's Status:Running

在这里，我们通过Thread类的静态属性CurrentThread获取了当前执行的线程，对其Name属性赋值“System Thread”，最后还输出了它的当前状态（ThreadState）。

所谓静态属性，就是这个类所有对象所公有的属性，不管你创建了多少个这个类的实例，但是类的静态属性在内存中只有一个。很容易理解CurrentThread为什么是静态的——虽然有多个线程同时存在，但是在某一个时刻，CPU只能执行其中一个。

在程序的头部，我们使用了如下命名空间：
     using System;
     using System.Threading; 
 
在.net framework class library中，所有与多线程机制应用相关的类都是放在System.Threading命名空间中的。如果你想在你的应用程序中使用多线程，就必须包含这个类。

我们通过其中提供的Thread类来创建和控制线程，ThreadPool类用于管理线程池等。
（此外还提供解决了线程执行安排，死锁，线程间通讯等实际问题的机制。）

Thread类有几个至关重要的方法，描述如下：
Start()：启动线程；
Sleep(int)：静态方法，暂停当前线程指定的毫秒数；
Abort()：通常使用该方法来终止一个线程；
Suspend()：该方法并不终止未完成的线程，它仅仅挂起线程，以后还可恢复；
Resume()：恢复被Suspend()方法挂起的线程的执行；

C#多线程学习系列：

C#多线程学习(二) 如何操纵一个线程
http://www.cnblogs.com/xugang/archive/2008/04/06/1138841.html

C#多线程学习(三) 生产者和消费者
http://www.cnblogs.com/xugang/archive/2008/03/23/1118594.html

C#多线程学习(四) 多线程的自动管理(线程池)
http://www.cnblogs.com/xugang/archive/2008/03/23/1118584.html

C#多线程学习(五) 多线程的自动管理(定时器)
http://www.cnblogs.com/xugang/archive/2008/03/23/1118537.html

C#多线程学习(六) 互斥对象
http://www.cnblogs.com/xugang/archive/2008/03/23/1118530.html

Introduction

This article is to guide you through creating and handling threads in .NET. It has two sections: in the first section, we will see about threading basics and how to create threads in .NET using C#. In the second section, we will see how to handle threads in WinForms.

1.1 Threading

1.1.1 Threading Basics

If you are familiar with threading basics, you can skip this topic.

A thread can be defined as a piece of code in execution. Each process has no less than one thread. So, all the processes get executed in terms of a thread. Any application will have an entry point called Main, and at the maximum, it can have only one Main. This is where an application starts. The thread which executes this Main function (i.e., starts the application) is called the main thread. This main thread can spawn any number of threads, depending upon the application requirement, to execute functionalities in parallel. Multiple threads in an application enable parallel execution. The term multiple threads signifies the total number of threads within a single process, not across different processes.

Multiple threads in execution is not similar to multiple process in execution. Each process has its own address space. The address space of one process cannot be used (read/write) by another process. Any communication between the processes should happen through some IPC (Inter Process Communication) mechanisms. But, multiple threads in a process share the process address space. They don't need any special mechanism for communication. They can communicate each other directly using a variable or some signals. Also, context-switching (this is how we achieve parallel execution using a single processor!!!) is time consuming to switch between processes, but not in the case of switching between threads. So, multiple threads enable parallel execution within a process effectively.

Do I really need multithreading?

Consider you have a calculator application which does some complex arithmetic operations. And, you need to provide a stop feature so that the user can stop the calculation at the middle, before letting it to finish. Having only one thread in your application is not possible to address this requirement. You can not process the stop function while you are doing an arithmetic operation. As the application will be busy with executing the arithmetic operation, it cannot handle the stop until the arithmetic operation is completed. Here, you need a thread which can execute the complex arithmetic operation, and another (the main thread) will listen to user inputs, in this case, the stop. When the main thread receives the stop signal, it can stop the thread spawned for execution of the arithmetic operation.

You have to be more careful when creating threads, because creating unwanted threads may reduce your application performance. Similarly, avoiding threads in required places will distress your application.

1.1.2 Threading in .NET

If you are familiar with delegates, you can skip this topic.

Before starting with threads, let's understand what delegates are. A delegate can be defined as a data type which holds an array of methods. All the methods inside a delegate should have the same signature and the same return type. The method signature and the return type of a delegate will be defined in the delegate declaration itself. The C# code for a delegate declaration is:

Collapse Copy Code

public delegate void MyDelegate(int arg);

Here, the delegate MyDelegate can hold methods with the signature void functionname(int k).

To add a function into a delegate, create the instance of the delegate and pass the function name as the argument.

Collapse Copy Code

MyDelegate delInstance = new MyDelegate(Function1);

Multiple functions can also be added in a delegate; to add more functions, use the += operator.

Collapse Copy Code

delInstance += new MyDelegate(Function2);

Here, Funtion1 and Function2 have the same signature as defined in the MyDelegate declaration. I.e., they should return void and take a parameter of type int.

Delegates can be invoked as normal functions, just by passing the arguments.

Collapse Copy Code

delInstance(5);

The above line of code will invoke all the functions inside the delInstance delegate, sequentially. First, Function1(5) will be called, and then Function2(5). This is called multicasting delegates, i.e., a single invoke of the delegate instance in turn calls multiple functions inside the delegate.

1.1.3 Creating Threads in .NET

Threads in .NET are created using the class "Thread". This class is available in the "System.Threading" namespace. To create a new thread, you need to create an instance of the Thread class and apply the Start method (available in the Thread class) on that instance. The Thread class constructor takes a ThreadStart delegate as a parameter. (ThreadStart is a delegate defined in the System.Threading namespace.) The signature of the ThreadStart delegate takes no arguments and returns void. So, the function to be executed in a separate thread should return void, and should not take any arguments.

The C# code for creating threads:

Collapse Copy Code

public static void main()
{
Thread t = new Thread(new ThreadStart(ClassName.MyFunction));
t.Start();
for(int i=0;i<100;i++)
Console.WriteLine("I am in Main Thread {0}",i);
}
public static void MyFunction()
{
for(int i=0;i<100;i++)
Console.WriteLine("I am in Different Thread {0}",i);
}

In the above code, we defined a function MyFunction which matches the ThreadStart delegate signature. Then, we created an instance for the Thread class, passing the ThreadStart delegate instance. Then, we started a separate thread to execute the MyFunction while the main thread which spawned the MyFunction in a separate thread was also running.

On executing this, we get the console messages swapped between the main thread and a different thread since both the Main and MyFunction 'for' loops are running in parallel.

This is how we create threads in .NET. Here, the Thread class can not take delegates of any signature as parameter, it just takes the ThreadStart delegate type as parameter, and the ThreadStart delegate can take only a function having no arguments and no return type.

Then, what if you want to execute a function in a thread which takes some argument? The answer for this question can be delegates.

Delegates have an inbuilt function called BeginInvoke() provided by the compiler. This function can be used for executing a function in a thread. BeginInvoke calls on any delegate will be executed in a separate thread.

The C# code follows:

Collapse Copy Code

public void MyDelegate(int i, string str);
public static void main()
{
MyDelegate delInstance = new MyDelegate (MyFunction);
delInstance.BeginInvoke(100," I am in Delegate Thread", null, null);
for(int i=0;i<100;i++)
Console.WriteLine("I am in Main Thread {0}",i);
}
public static void MyFunction(int count, string str)
{
for(int i=0;i<count;i++)
Console.WriteLine(str + " {0}",i);
}

In the above code, the BeginInvoke call on the delegate instance runs the MyFunction in a separate thread. The output of the above code will be, console messages swapped between the main thread and the delegate thread (similar to using the Thread class). Note that multicasting a delegate through BeginInvoke is not possible.

Here, our MyFunction returns no value. What if the function returns some value? How do we collect the return value?

As BeginInvoke is an asynchronous call (just triggers the other thread and keeps running the next line, not waiting to finish the other thread), it cannot get the return value of the function call directly. So, we need some mechanism to collect the return value. The implementation of the BeginInvoke function in C# returns an IAsyncResult type. This IAsyncResult can be used for getting the return value, when required. There is a function called EndInvoke, which takes this IAsynResult as argument and collects the return value. So, the EndInvoke function can be used to collect the return value.

Every EndInvoke should be associated with a BeginInvoke as EndInvoke operates on the return value of BeginInvoke.

The return value can be collected with the following C# code:

Collapse Copy Code

public bool MyDelegate(int i, string str);
public static void main()
{
MyDelegate delInstance = new MyDelegate (MyFunction);
IAsyncResult ref = delInstance.BeginInvoke(100,
"I am in Delegate Thread", null, null);
for(int i=0;i<100;i++)
Console.WriteLine("I am in Main Thread {0}",i);
bool status = delInstance.EndInvoke(ref);
}
public static bool MyFunction(int count, string str)
{
for(int i=0;i<count;i++)
Console.WriteLine(str + " {0}",i);
return true;
}

In the above code, the call to the EndInvoke function takes the IsyncResult type returned by the BeginInvoke, and returns the value returned by the MyFunction. Thus, the EndInvoke can be used to obtain the result of BeginInvoke.

Consider the following program in C#:

Collapse Copy Code

public void MyDelegate(int i, string str);
public static void main()
{
MyDelegate delInstance = new MyDelegate (MyFunction);
delInstance.BeginInvoke(1000, "I am in Delegate Thread", null, null);
}
public static void MyFunction(int count, string str)
{
for(int i=0;i<count;i++)
Console.WriteLine(str + " {0}",i);
}

If we look at the program closely, the main thread finishes its execution before the other thread is finished. When the main thread is destroyed, all the other threads automatically get destroyed. So, you may not get the desired output. To avoid this problem, we can use EndInvoke. The EndInvoke function can also be used for blocking the current thread until the corresponding thread finishes its execution. A call to EndInvoke will block the current thread.

The C# code using EndInvoke to block the thread follows:

Collapse Copy Code

public void MyDelegate(int i, string str);
public static void main()
{
MyDelegate delInstance = new MyDelegate (MyFunction);
ISyncResult ref = delInstance.BeginInvoke(100," I am in Delegate Thread",
null, null);
delInstance.EndInvoke(ref);
}
public static void MyFunction(int count, string str)
{
for(int i=0;i<count;i++)
Console.WriteLine(str + " {0}",i);
}

In the above code, the call to the EndInvoke blocks the main thread until the MyFunction is completed.

A call to EndInvoke will collect the return value immediately if the thread has completed its execution already; otherwise, it will wait until the thread is completed and gets the result.

While making the call to BeginInvoke, we have not created any thread, then who is creating the thread? How does it run in a separate thread?

To answer these questions, let's first know what thread pools are.

1.1.4 Thread Pool

Creating a thread at runtime is not an easy job. Most of the time will be spent on creating the thread rather than executing the functionality on the thread, in the case of smaller threads.

The CLR (Common Language Runtime) has some threads created already in a pool so that they can be used whenever required. These threads are called Thread Pool threads. If we are using a thread in the thread pool, on completion of a thread, the thread will not be destroyed. The thread will return to the thread pool in suspended state. This suspended thread can be reused for other purposes.

The BeginInvoke function uses these Thread Pool threads to execute functionalities. The usage of thread pool threads saves the thread creation time.

1.2 Threading in WinForms

In section 1.1, we saw how to create a thread using the Thread class and delegates. In this section, let us see how to handle threads in WinForms. (This article assumes that you have worked on WinForms applications.)

1.2.1 WinForms Internals

Before starting with the threads directly, let's understand how a Windows application works. Consider you have a Windows application where you create a text box and add the text box to the form. The C# code follows:

Collapse Copy Code

Form1_Load(……)
{
AddControl();
}
Void AddControl()
{
TextBox textBox1 = new TextBox();
Controls.add(textBox1);
}

On loading the form, the AddControl function is invoked, and it creates a text box and adds it to the form using the Controls.Add method.

The above code will run without any errors.

Consider the same application, where we would like to call the AddControl() method in a thread. The C# code follows:

Collapse Copy Code

Form1_Load(……)
{
Thread t = new Thread(new ThreadStart(RunInThread));
t.Start();
}
Void RunInThread()
{
AddControl();
}
Void AddControl()
{
TextBox textBox1 = new TextBox();
controls.add(textBox1);
}

There is no change, except we call the function AddControl from a separate thread (not from the main thread). Here, the functions RunInThread and AddControl run in the same thread. If you try to run the above code, though the code will compile without any errors, you will receive a runtime error saying: "Controls created on one thread cannot be parented to a control on a different thread." This is what we should worry about when dealing with threads in WinForms.

So, why do we get this runtime error? A rule in Windows is that "a control created on one thread cannot be modified in another thread". In the second example, the form was created in the main thread, and we were trying to modify the form object from another thread. That is a violation of the Windows rule (why do we have the rule is a different topic to explain). It throws the runtime error as we tried to update the control from a different thread. We can simply say that any update on the UI should happen only through the main thread.

Then, how do we update the UI while we are in a different thread? Before looking at the answer, let us understand how Windows applications work.

All Windows applications have two queue structures, the send message queue and the post message queue. These queues will have actions to be performed. The main thread is responsible for executing all the tasks in the queue. The main thread will dequeue the messages one by one and executes them.

• Post Message Queue
• Send Message Queue
• Main Thread

The post message queue will have messages posted through the PostMessage function. Similarly, the send message queue will have messages posted by the SendMessage function. The difference between SendMessage and PostMessage is that SendMessage will block the call until it is executed. But PostMessage just puts the message in the queue and returns. The main thread first executes the send message queue messages and then it starts executing the post message queue messages.

So, the answer for our question on how to update the UI while we are in different thread is to put it in the message queue. The next question is how to post/send a message in .NET?

Answering this question is very simple. A Control class has three methods:

• Invoke
• BeginInvoke
• EndInvoke

The Invoke method does SendMessage. The BeginInvoke method does PostMessage. The EndInvoke method is used as part of BeginInvoke to obtain the results of the BeginInvoke call (as discussed in section 1.1).

1.2.2 Control.Invoke

As mentioned earlier, the Invoke method on the Control class places a calls into the send message queue. The call will ultimately be executed by the main thread, and the Invoke method will block the current thread until the call is returned.

The Invoke method on the Control class has two overloads:

• public System.Object Invoke ( System.Delegate method )
• public virtual new System.Object Invoke ( System.Delegate method , object[] args )

The argument takes the delegate to be executed on the Main thread. If the parameters need to be passed for the delegate, they can be passed as an object array. The return value can also be obtained as an object.

Now, let's go back to the program:

Collapse Copy Code

public delegate void MyDelegate();
Form_Load(……)
{
Thread t = new Thread(new ThreadStart(RunInThread));
t.Start();
}
void RunInThread ()
{
MyDelagate delInstatnce = new MyDelagate(AddControl);
this.Invoke(delInstatnce);
MessageBox.Show("Hello");
//Add your code that needs to be executed in separate thread 
//except UI updation
}
void AddControl()
{
TextBox textBox1 = new TextBox();
Controls.add(textBox1);
}

Here, we try to execute the AddControl function in a different thread, using the RunInThread function. The RunInThread function is executed in a separate thread. We try to call the AddControl function inside the RunInThread function through a delegate. Though the RunInThread function runs in a separate thread, this.Invoke (here, the 'this' means the Form object) puts the function to be executed in the send message queue. So, the function is ultimately executed in the main thread in which the form was created. So, it never throws an exception. (Note that, here the AddControl and RunInThread functions are not executed in the same thread.) The call to the Invoke function will block the current thread until the AddControl function is completed fully, i.e., the message box will appear only after the complete execution of the AddControl call.

1.2.3 Control.BeginInvoke

As seen earlier, the BeginInvoke method on the Control class places the call into the post message queue. This call will ultimately be executed by the main thread, and the BeginInvoke method will not block the current thread as Invoke does. It will start executing the next line after placing the call in the post message queue. The return value can be collected using the EndInvoke method.

Similar to the Invoke method, BeginInvoke has two overloads in the Control class:

• public System.IAsyncResult BeginInvoke ( System.Delegate method )
• public virtual new System.IAsyncResult BeginInvoke ( System.Delegate method , object[] args )

The arguments are similar to those of BeginInvoke, but the return type here is IAsynResult. This IAsynresult can be used for collecting the result using EndInvoke.

Collapse Copy Code

Public delegate void MyDelegate();
Form_Load(……)
{
Thread t = new Thread(new ThreadStart(RunInThread));
t.Start();
}
void RunInThread()
{
MyDelagate delInstatnce = new MyDelagate(AddControl);
this.BeginInvoke(delInstatnce);
MessageBox.Show("Hello");
}
void AddControl()
{
TextBox textBox1 = new TextBox();
Controls.add(textBox1);
}

Since we have used the BeginInvoke here, we could see the message box displayed before the AddControl is completed.

Consider the following C# code:

Collapse Copy Code

public delegate void MyDelegate();
Form_Load(……)
{
MyDelagate delInstatnce = new MyDelagate(AddControl);
this.BeginInvoke(delInstatnce);
for(int i=0; i<1000; i++)
textBox1.Text += "Main " + i.ToString();
}
void AddControl()
{
for(int i=0; i<1000; i++)
textBox1.Text += "Thread " + i.ToString();
}

The above code will not run in parallel, since both the loops have to run in the main thread. First, it will print all the Form_Load 'for' loop messages, and then it will print the AddControl 'for' loop messages.

Consider the same C# code for the Invoke call:

Collapse Copy Code

public delegate void MyDelegate();
Form_Load(……)
{
MyDelagate delInstatnce = new MyDelagate(AddControl);
this.Invoke(delInstatnce);
for(int i=0; i<1000; i++)
textBox1.Text += "Main " + i.ToString();
}
void AddControl()
{
for(int i=0; i<1000; i++)
textBox1.Text += "Thread " + i.ToString();
}

The above code will not run in parallel either, since both the loops have to run in the main thread. First, it will print all the AddControl 'for' loop messages, and then it will print the Form_Load 'for' loop messages. As opposed to the earlier one, the Invoke method blocks the call.

1.2.4 Control.InvokeRequired

Consider the following C# code:

Collapse Copy Code

Form_Load(……)
{
MyDelagate delInstatnce = new MyDelagate(AddControl);
this.Invoke(delInstatnce);
}
void AddControl()
{
TextBox textBox1 = new TextBox();
Controls.add(textBox1);
}

In the above code, we unnecessarily use the Invoke method, though we are there in the main thread already. Here, we know that we are in the main thread, and we can avoid using Invoke/BeginInvoke. But in some cases, we don't know whether the particular function will be executed by the main thread or by some other thread. And, the caller doesn't know whether the particular function has any UI update code. So, the function which updates the UI should take care of taking the current thread to the main thread. For that purpose, we have a member "InvokeRequired" in the Control class which returns true if the current thread is not the main thread, false if the current thread is the main thread. So, any update in the UI should happen through the InvokeRequired property as a safe coding practice. The caller won't handle the Invoke methods, rather the implementation inside the function will do.

The C# code follows:

Collapse Copy Code

Form_Load(……) //this function runs in main thread.
{
AddControl();
}
void RunInThread() //this function runs in a different thread.
{
AddControl();
}
void AddControl()
{
if(this.InvokeRequired)
{
MyDelagate delInstatnce = new MyDelagate(AddControl);
this.Invoke(delInstatnce);
return;
}
TextBox textBox1 = new TextBox();
Controls.add(textBox1);
}

Here, the caller just calls the function, but the function implementation takes the current thread to the main thread, if required. In the above code, the Form_Load call to AddControl won't use the Invoke method but the RunInThread call to AddControl will use the delegate Invoke method.

The BeginInvoke available in the delegate and the BeginInvoke available in the Control class are not the same. The BeginInvoke on the delegates uses the thread pool threads to execute the function in parallel. But the BeginInvoke in the Control class just posts a message in the message queue. It will not create a separate thread to run the function. So, the delegate BeginInvoke may enable parallelism, but the Control BeginInvoke may not.

无论是WIN32还是Windows Form还是WPF还是Swing，都不支持GUI线程之外的线程直接访问其API。今天我们来回顾一下这个发展过程。一个普通的操作是怎么被封装封装再封装的。

Win32

在Windows SDK时代，我们都知道，界面就是一个大的WndProc控制的。

switch (message)
{
        case WM_PAINT:

        case WM_DESTROY:

        default:
            return DefWindowProc(hWnd, message, wParam, lParam);
}

如果我们需要另外一个线程去做一些耗时的IO操作，同时要回调回来更新的界面，这个时候要么自己定义一个回调队列，然后在WM_IDLE的时候处理，要么就利用窗口本身的消息队列，自己创建一个消息类型：

// at startup
int OUR_APP_IO_COMPLETED = RegisterWindowMessage("OUR_APP_IO_COMPLETED");
----
// after io completed
PostMessage(hwnd, OUR_APP_IO_COMPLETED, xxx, xxx);

这样，我们就可以让界面更新的操作在GUI线程完成了。

.NET 1.0 Windows Forms

Windows Forms的出现使得很多东西简单多了。跨线程的GUI操作也简化了许多。因为我们有了Delegate和Control.Invoke。前者就是一个函数指针的升级版，Control.Invoke就是PostMessage的升级版：

public delegate void IOCompletedHandler();
public void OnIOCompleted() {
  control.Invoke(new IOCompletedHandler(HandleIOCompleted));
}
public void HandleIOCompleted() {

}

在内部Control维护了一个threadCallbackList。调用Invoke相当于

1、把Delegate和参数封装到一起，压入到threadCallbackList中

2、确保ThreadCallbackMessage被注册了（RegisterWindowMessage）

3、PostMessage，触发Callback

4、WaitForHandle，等待GUI线程完成处理（如果是BeginInvoke则可以省略这个步骤）

而Windows Forms的WndProc的消息循环，就需要加一个case语句，来响应PostMessage。在得到消息的同时，去threadCallbackList中取出需要回调的Delegate，然后一一调用。

Control.Invoke确实是让我们的生活方便很多。但是它还是不能避免所谓的BeginInvoke之舞（BeginInvoke Dance）：

//http://ikriv.com:8765/en/prog/info/dotnet/MysteriousHang.html
delegate void MyHandlerDelegate();        
void MyHandler()
{
    // "The BeginInvoke dance"
    if (this.InvokeRequired) // assuming this descends from Control
    {
        BeginInvoke( new MyHandlerDelegate(MyHandler) );
        return;
    }
    // assume we are on the main GUI thread
     do GUI stuff 
}

InvokeRequired内部实现就是线程安全地比较一下当前线程和GUI线程的线程ID是不是相等的。

另外Control.Invoke还需要我们确保对应的Control的句柄已经创建。为了避免这个问题，WinForm有一个MarshingControl可以给我们使用。

Application.ThreadContext.FromCurrent().MarshingControl;

.NET 2.0 Windows Forms

如果我提供了一个回调接口。我一般会直接调用回调方法，如果我知道回调方法必须在GUI线程中执行的话，用必须用Control.Invoke来调用回调方法。所以，在缺乏信息的情况下，回调接口的提供者是没有办法保证回调方法的执行线程的环境的。所以，按照Strategy模式，我们可以定义一个CallbackStrategy

public interface CallbackExecutor {
  void Execute(Delegate callback, object[] args);
}
public class DefaultCallbackExecutor : CallbackExecutor {
  public void Execute(Delegate callback, object[] args) {
    callback.Invoke(args);
  }
}
public class WindowsFormsCallbackExecutor : CallbackExecutor {
   private Control marshalingControl;
   public WindowsFormsCallbackExecutor() {
     Application.ThreadContext context = Application.ThreadContext.FromCurrent();
        if (context != null)
        {
            this.marshalingControl= context.MarshalingControl;
        }
  }
  public void Execute(Delegate callback, object[] args) {
     marshalingControl.Invoke(callback, args);
  }
}

然后回调方法的提供者就不用为难了，它只要调用CallbackExecutor就可以了，同时回调方法也可以安心地直接去干自己的事情。从而，谁都不需要做BeginInvoke Dance了。

这就是.NET引入的SynchronizationContext的基本原理。由于微软不是接口爱好者，所以它省去了共同的那个接口，直接让WindowsFormSynchronizationContext继承自SynchronizationContext类了。SynchronizationContext是线程唯一的，取得当前线程的Sync Context可以使用：

SynchronizationContext.Current.Post(delegate{//your code}, null);

与SynchronizationContext类同时引入的还有AsyncOperationManager，AsyncOperation。它又是SynchronizationContext的封装。一般来说，推荐使用AsyncOperationManager。AsyncOperationManager在创建AsyncOperation的时候会取得当前线程的Sync Context，并存储在SyncOperation之中。 所以后来利用AsyncOperation来回调的时候，就会用一开始创建时候所在线程的context来回调。

// initialize in GUI thread
asyncOperation = AsyncOperationManager.Create(null);

// when you want to call back
asyncOperation.Post(delegate{//your code}, null);

像BackgroundWorker这样的类，之所以其Callback可以直接访问GUI，其秘诀就在于回调不是直接调用的，而是有 AsyncOperation来间接代劳的。只要AsyncOperation是在GUI线程创建的，所有由它代劳的回调都会经过 MarshalingControl来做Control.Invoke。

.NET 3.0 WPF

Control.Invoke变成了Dispatcher.Invoke。内部实现还是一样的，有一个Callback队列，然后PostMessage。同时引入的还有DispatcherSynchronizationContext。

Conculsion

从直接PostMessage到Control.Invoke到SynchronizationContext到AsyncOperationManager到BackgroundWorker，职责最终推卸到了回调的提供方。但是由于引入的时间不一致，很多回调提供方是没有使用AsyncOperation的。这个时候，我们自己需要自己去包装，比如：

Code
using System;
using System.ComponentModel;
using System.Net;
using log4net;

namespace xxx
{
    public class WebClientFileUploader : FileUploaderListeners, FileUploader
    {
        private static readonly ILog LOGGER = LogManager.GetLogger(typeof (WebClientFileUploader));
        private readonly WebClient webClient;
        private readonly Uri address;
        private readonly AsyncOperation asyncOperation;

        public WebClientFileUploader(Uri address)
        {
            asyncOperation = AsyncOperationManager.CreateOperation(null);
            webClient = new WebClient();
            webClient.UploadFileCompleted += HandleUploadFileCompleted;
            this.address = address;
        }

        private void HandleUploadFileCompleted(object sender, UploadFileCompletedEventArgs eventArgs)
        {
            try
            {
                var result = eventArgs.Result;
                LOGGER.Info("Request completed.");
                asyncOperation.Post(state => HandleCompleted(result), null);
            }
            catch (Exception exception)
            {
                LOGGER.Error("Request failed.", exception);
                asyncOperation.Post(state => HandleError(exception), null);
            }
        }

        public void Cancel()
        {
            LOGGER.Info("Cancelling the request.");
            webClient.CancelAsync();
        }

        public void Upload(string fileName)
        {
            LOGGER.Info("Starting to upload to " + address + " with file " + fileName + " using real web client.");
            webClient.UploadFileAsync(address, WebRequestMethods.Http.Post, fileName);
        }
    }
}

这样，我们就不需要在手工地去用Control.Invoke了，也不应该再直接用Control.Invoke了

-左對齊,若不足指定的長度,則右側補足缺少的空格數.

沒有任何符合,右對齊, 若不足指定的長度,則左側補足缺少的空格數.

.最大長度,若超過指定的最大長度,則從右側進行截斷.

Microsoft .Net Remoting系列专题之三：Remoting事件处理全接触

大坏蛋

.NET Remoting中的事件处理(.NET Framework 2.0)

.NET Remoting的新特性-IpcChannel(.NET Framework 2.0)

iBATIS DataMapper is a Java/.NET framework that will help you design and implement better persistence layers for your Java/.NET applications. iBATIS couples objects with stored procedures or SQL statements using a XML descriptor. Simplicity is the biggest advantage of the iBATIS Data Mapper over object relational mapping tools.

To use iBATIS Data Mapper you rely on your own objects, XML, and SQL. There is little to learn that you don't already know. With iBATIS Data Mapper you have the full power of both SQL and stored procedures at your fingertips.

Our sample project

This sample takes an "over-the-shoulder" Cookbook approach. We'll define a simple data access problem and use iBATIS to solve it for us. Let's say our client has a database and one of the tables in the database is a list of people. The client tells us:

"We would like to use a web application to display the people in this table and to add, edit, and delete individual records."

Not a complicated story, but it will cover the CRUD most developers want to learn first.

Step 1 : The SQL

Let's start with the people table client mentioned. Since we're keeping it simple, we'll say it's a table in an Access database. The table definition is shown as

Step 2 :The.NET Class

using System;
namespace iBatisTutorial.Model
{
public class Person
{
private int _id;
private string _firstName;
private string _lastName;
private DateTime _birthDate;
private double _weightInKilograms;
private double _heightInMeters;
public int Id
{
get{ return _id; }
set{ _id = value; }
}
// Other public properties for the private fields ...

}
}

Step 3 :The Nunit test

The first thing our story says is that client would like to display a list of people.

using System.Collections;
using IBatisNet.DataMapper;
using NUnit.Framework;
namespace iBatisTutorial.Model
{
[TestFixture]
public class PersonTest
{
[Test]
public void PersonList ()
{
// try it
    IList people = Mapper.Instance().QueryForList("SelectAll",null);
// test it
    Assert.IsNotNull(people,"Person list not returned");
Assert.IsTrue(people.Count>0,"Person list is empty");
Person person = (Person) people[0];
Assert.IsNotNull(person,"Person not returned");
}
}
}

OK, that was fun! The Assert class is built into NUnit, so to compile, we just need the Mapper object and QueryForList method. The Mapper is built into the iBATIS framework, so we don't need to write that either. The iBATIS QueryForList method executes our SQL statement (or stored procedure) and returns the result as a list.
Each row in the result becomes an entry in the list. Along with QueryForList, there is also Delete, Insert, Select, QueryForObject, and a couple of other methods in the iBATIS API. (See the Developers Guide for details.)

Looking at PersonTest class, we see that the QueryForList method takes the name of the statement we want to run and any runtime values the statement may need. Since a "SelectAll" statement wouldn't need any runtime values, we pass null in our test.

OK. Easy enough. But where does iBATIS get the "SelectAll" statement?

Some systems try to generate SQL statements for you, but iBATIS specializes in data mapping, not code generation. It's our job (or the job of our database administrator) to craft the SQL or provide a stored procedure. We then describe the statement in an XML element, like the one shown below.

Step 4 :The mapping file

<alias>
<typeAlias alias="Person" type="iBatisTutorial.Model.Person, iBatisTutorial.Model" />
</alias>
<resultMap id="SelectAllResult" class="Person">
<result property="Id" column="PER_ID" />
<result property="FirstName" column="PER_FIRST_NAME" />
<result property="LastName" column="PER_LAST_NAME" />
<result property="BirthDate" column="PER_BIRTH_DATE" />
<result property="WeightInKilograms" column="PER_WEIGHT_KG" />
<result property="HeightInMeters" column="PER_HEIGHT_M" />
</resultMap>
<select id="SelectAll" resultMap="SelectAllResult">
select
PER_ID,
PER_FIRST_NAME,
PER_LAST_NAME,
PER_BIRTH_DATE,
PER_WEIGHT_KG,
PER_HEIGHT_M
from PERSON
</select>

The iBATIS mapping documents can hold several sets of related elements, like those shown. We can also have as many mapping documents as we need. Having multiple mapping documents is handy when several developers are working on the project at once.

So, the framework gets the SQL code for the query from the mapping, and plugs it into a prepared statement. But, how does iBATIS know where to find the table's datasource?

Surprise! More XML! You can define a configuration file for each datasource your application uses. The example below shows a configuration file for our Access database.

Step 5 :The configuration file

<?xml version="1.0" encoding="UTF-8" ?>
<sqlMapConfig
xmlns="http://ibatis.apache.org/dataMapper"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" >
<database>
<provider name="OleDb1.1"/>
<dataSource name="iBatisTutorial"
connectionString="Provider=Microsoft.Jet.OLEDB.4.0;Data Source=./Resources/iBatisTutorial.mdb"/>
</database>
<sqlMaps>
<sqlMap resource="Resources/Person.xml" />
</sqlMaps>
</sqlMapConfig>

Of course, besides Access, other ADO.NET providers are supported, including SqlServer, Oracle, MySQL, PostgreSQL, DB2 and generic OLEDB, ODBC providers. (See the Developers Guide for details.)

The last part of the configuration file ("sqlMaps") is where we list our mapping documents, like the one shown back in Step 4. We can list as many documents as we need here, and they will all be read when the configuration is parsed.

OK, so how does the configuration get parsed?

Look back at PersonTest class in step 3. The heart of the code is the call to the "Mapper" object (under the remark "try it"). The Mapper object is a singleton. The first time it's called, it reads in the configuration documents to create the Mapper object. On subsequent calls, it reuses the Mapper object, so that the configuration is re-read only if the file changes.

The framework comes bundled with a default Mapper class. If you want to use a different name for the configuration file, or need to use more than one database, you can also use your own class, by copying and modifying the standard version.

The following example shows the code for the standard Mapper class that comes with the framework.

using IBatisNet.Common.Utilities;
using IBatisNet.DataMapper;
namespace IBatisNet.DataMapper
{
public class Mapper
{
private static volatile SqlMapper _mapper = null;
protected static void Configure (object obj)
{
_mapper = (SqlMapper) obj;
}
protected static void InitMapper()
{
ConfigureHandler handler = new ConfigureHandler (Configure);
_mapper = SqlMapper.ConfigureAndWatch (handler);
}
public static SqlMapper Instance()
{
if (_mapper == null)
{
lock (typeof (SqlMapper))
{
if (_mapper == null) // double-check
      InitMapper();
}
}
return _mapper;
}
public static SqlMapper Get()
{
return Instance();
}
}
}

You can access as many different database configurations as you need, just by setting up additional Mapper classes. Each Mapper configuration is a facade for a database. As far as our application knows, the "Mapper" is the database. Behind the Mapper facade, you can change the location of the database, or switch between SQL statements and stored procedures, with zero-changes to your application code.

Step 5 :Running the test

If we put this all together into a solution, we can "green bar" our test, as shown by figure.

简单：
 易于学习，易于使用，通过文档和源代码，可以比较完全的掌握它的设计思路和实现。

实用：
 提供了数据映射功能，提供了对底层数据访问的封装（例如ado.net），提供了DAO框架，可以使我们更容易的开发和配置我们的DAL层。
 
灵活：
 通过sql基本上可以实现我们不使用数据访问框架可以实现的所有功能，或许更多。
 
功能完整：
 提供了连接管理，缓存支持，线程支持，（分布式）事物管理，通过配置作关系对象映射等数据访问层需要解决的问题。提供了DAO支持，并在DAO框架中封装了ADO.NET，NHibernate和DataMapper。
 
增强系统的可维护性：
 通过提供DAL层，将业务逻辑和数据访问逻辑分离，使系统的设计更清晰，更易维护，更易单元测试。sql和代码的分离，提高了可维护性。
 
2.缺点
滞后性：
 还没有明确对.NET2.0的支持。最新版本在2.0下编译可以，但有些单元测试不能通过。
不成熟，工程实践较少：
 IbatisNet在实际项目中的使用较少。 只是理论上可行.
半ORM，工具支持较少：
 需要我们自己写sql，并且.NET下还未发现可以自动生成业务层类和配置文件的工具，这点和NHibernate不一样，NHibernate会为我们的数据库直接产生sql，并有一些辅助工具。因此使用Ibatis比NHibernate要多做一些工作。
 
3.可行性
    没有最好的框架，只有最适合的框架。 存在的便是合理的，它存在就说明有它存在的道理。但它未必为我们存在。所以选择一个框架最主要的是看它对你有没有意义，意义有多大，是不是比其他框架带给你的好处要多。没有绝对的优点也没有绝对的缺点，重要的是看在什么情况下讨论。
    上面说了部分的Ibatis的优点和部分缺点。这些优点从理论上证明Ibatis对任何数据持久层都合适，但未必是最好的选择。下面对上面的优缺点分别从两方面讨论。
 
简单：
    我们都喜欢简单，简单意味着学习成本低，使用中出错的可能性低。同时，简单的东西一般来说功能不够强大。反过来，复杂的东西学习成本高，用起来不方便，并且团队没有很强的技术实力，一般不要使用。
实用：
    解决了项目中需要解决的问题，这是任何实际工程中采用的框架和工具都应具有的性质，否则就不要拿到实际项目中来。
灵活：
    灵活有两层意思，一种是简单易扩展，另一种是功能强大提供了很多选项。Ibatis属于前者，Hibernate属于后者。两者各有优缺点。
功能完整：
    Ibatis的功能完整也是相对的，比我们自己开发的框架应该完整，但对比其他框架肯定也有一些解决不了的问题。
增强系统的可维护性：
    利用Ibatis可以做到sql和代码分离，可以设计出一个清晰的数据访问层（DAL）。但项目架构是否科学合理，是否以维护，关键不在Ibatis，因为它只是一个数据层框架。但是我们也不得不清楚，要想发挥Ibatis的优势，我们需要做一些额外工作，比如最好设计DAO接口，需要将业务层实体和对实体的访问放在不同的工程中，同时需要维护xml配置文件。
滞后性：
    Ibatis组现在还没有提到要支持.NET2.0，很多人在.NET2.0下使用Ibatis都出现了问题。所以如果要使用.NET2.0开发，IBatis不是一个好选择，还需要等待。
不成熟：
    开源的东西很难说成熟，但一般比我们自己写的框架要成熟。由于我们可以拿到他的源代码，所以关键在于我们能否驾驭它。
半ORM，工具支持少：
    这注定了Ibatis不能从本质上提升开发效率，我们需要自己写sql，写实体类，写配置文件。但这也是它优越的地方，它没有为我们做的他多，所以我们就有更多的施展空间。而且它非常适合那些并不能完全控制数据库的系统和需要利用数据库本身提供的高级特性的统计查询系统的开发。
    使用Ibatis需要自己写sql，由于我们的sql不可能完全符合sql标准，比起NHibernate产生的sql来，可移植性差。不过由于我们更改数据库的可能性较小，对我们来说sql符合标准以便可以在迁移到不同服务器时代价最小并不是十分必要的。另一方面，NHibernate虽然可以屏蔽很多数据库间的不同，但是却很难利用某些数据库的高级特性，比如Oracle的分析统计函数。
     NHibernate不适合数据库模式不规范，约束不完整，需要大量复杂查询的系统，同时NHibernate的学习成本较高，完全掌握NHibernate也较困难，风险较大。
    自己写框架未必比Ibatis的好，稳定，强大和可扩展。而且自己开发框架也需要较大的工作量。
    如果使用DotNet并且要选一个数据层框架，而系统中有相当一部分较复杂的sql，或数据库设计不合理，脏数据多，对性能和资源要求严格，Ibatis是一个比较不错的选择。他的那些缺点并不是致命的，而且也是有一些解决方案的。尤其是，当选用了Ibatis的DataAccess作为DAO框架时，我们可以同时使用NHibernate，ADO.NET和DataMapper（IbatisNet的核心组件），那样将会使风险降到最低，并且整个系统的框架比较合理。
 另外，利用Ibatis可以统一编码风格，节约开发成本，大家不会再把精力浪费到分页  连接池 主键生成等地方了,可以集中精力进行业务组件的编写。 

综上:         很多时候我们要在是自己开发框架和选用第三方框架和选用什么样的框架问题上进行综合考虑。考虑的标准当然是项目的当前情况和我们希望达到目的的一个平衡。

     Ibatis只是封装了数据访问层，替我们做了部分的对象关系映射。但我们的代价是必须要写xml配置文件，相对于Hibernate我们还要写很多sql。Hibernate通过工具直接从数据库模式生成实体类和基本的配置文件，而且大部分情况下不需要我们写sql，会较大的提升开发效率。但这些也有很多的局限性，尤其是对环境的要求较高（数据库设计，对象设计，团队的协作等）。
 
    个人感觉Ibatis对项目比较有意义的地方在于它小巧灵活，可扩展，封装了数据访问层（事务，缓存，异常，日志），并提供了DAO框架支持。
    利用Ibatis我们可以做到代码和sql的分离，只要sql能够解决的问题，Ibatis就能帮我们较容易的解决，同时也使我们的项目对某一框架的依赖性变小（因为Ibatis是非侵入性的）。这将极大的降低项目风险，减少解决复杂问题的时间，使项目的维护变得简单。
   Ibatis对于应用的修改，调试，扩充和维护将会变得容易自然。修改时，我们主要修改的是代表模型的实体对象，xml配置文件中的sql，和/或配置文件的ResultMap（很多时候是不需要的）。同时，sql和代码分离，我们不用在代码的StringBuffer的append方法之间寻找需要修改的sql。配置文件中的sql便利了我们的调试和对sql的评审及以后的sql重用。
    利用一些框架在前期一般会拖慢开发效率。因为我们需要付出学习成本，很多时候，使用框架需要写很多配置文件，在使用不熟时开发速度较慢；同时利用框架往往使系统代码量增大，比如Model1和Model2模型，开发效率应该还是Model1快，四层的架构肯定比两层的代码量大。 但对于中后期开发和维护将会极大的提高效率。
    利用一些较完全的开发框架和代码生成工具，在前期会较大的提高开发效率，但在后期常常会拖慢进度，并有可能成为以后维护的梦魇。比如torque生成实体类和其对应的sql，虽大幅提高了效率，但修改负担较大。
   比较理想的开发方式是使用简单框架结合简单的代码生成工具。框架提供系统的基础服务，并规范开发。框架一方面提供了开发中某一方面的开发基础支持，比如数据访问层，事务，日志，公用类，异常等。另一方面，也为开发定义了模式，定义了系统的基本轮廓。同时，通过简单的代码生成工具生成部分低级的代码。比如通过工具从数据库模式生成实体类。这些类生成后我们可以自由修改。
 
    Hibernate是十分强大，比较完善的ORM框架，不过这是它的优点也是它的缺点。 j2ee系统是否采用Hibernate3，是一个需要认真评估的问题。
    要想Hibernate工作的好，数据库的设计必须好。同时对于复杂的数据操作同时需要使用sql，Hibernate3对于直接使用sql的支持比Hibernate2要自然，这一点是可以接受的。
    Hibernate比较复杂，功能强大而灵活，要用好Hibernate确实不是很简单，当然Spring框架提供了对Hibernate的封装，使Hibernate的使用变得简单了点。
 
    可以说Ibatis在任何系统里都适用，但未必是最好选择。不过Ibatis提供的思路是我们应该仔细考虑的。

从上面IL代码看出，处理流程跟以前处理str是一样的，只是因为引用类型特性的原因，返回的结果就跟值类型有所不同。

另外我们还看到IL处理try finally的时候，.NET1.1和.NET2.0生成的IL有少许不同。Quiz:who win in finally vs return? 中的是.NET1.1的版本。此为.NET2.0的版本。

      lock是每个程序员都熟知的语句，但究竟它如何工作的呢?
我们先来看几个案例,看看lock是什么.

 

 1     public class ThreadTest
 2     {
 3         private int i = 0;
 4         public void Test()
 5         {
 6             Thread t1 = new Thread(Thread1);
 7             Thread t2 = new Thread(Thread2);
 8             t1.Start();
 9             t2.Start();
10         }
11         public void Thread1()
12         {
13             lock (this)
14             {
15                 Console.WriteLine(this.i);
16                 Thread.Sleep(1000);
17                 Console.WriteLine(this.i);
18             }
19         }
20         public void Thread2()
21         {
22             Thread.Sleep(500);
23             this.i = 1;
24             Console.WriteLine("Change the value in locking");
25         }
26     }
27     public class ThreadTest2
28     {
29         private int i = 0;
30         public void Test()
31         {
32             Thread t1 = new Thread(Thread1);
33             Thread t2 = new Thread(Thread2);
34             t1.Start();
35             t2.Start();
36         }
37         public void Thread1()
38         {
39             lock (this)
40             {
41                 Console.WriteLine(this.i);
42                 Thread.Sleep(1000);
43                 Console.WriteLine(this.i);
44             }
45         }
46         public void Thread2()
47         {
48             lock (this)
49             {
50                 Thread.Sleep(500);
51                 this.i = 1;
52                 Console.WriteLine("Can't change the value in locking");
53             }
54         }
55     }

 

      两段程序有什么区别吗?看看吧,ThreadTest2.Thread2()中多了一个lock(this)却产生了不同的结果

      本想在案例一中lock住this对象,让其他的线程不能操作,可是事情不是像我们想象的那样lock(this)是lock this的意思.this中的属性依然能够被别的线程改变.那我们lock住的是什么?是代码段,是lock后面大括号中代码段,这段代码让多个人执行不不被允许的.那返回头来在看lock(this),this是什么意思呢?可以说this知识这段代码域的标志,看看案例二中Thread2.Thread2就明白了,Thread2中的lock需要等到Thread1种lock释放后才开始运行,释放之前一直处于等待状态,这就是标志的表现.

      好吧,让我们来了解一下,lock这段代码是怎么运行的.lock语句根本使用的就是Moniter.Enter和Moniter.Exit,也就是说lock(this)时执行Moniter.Enter(this),大括号结束时执行Monitor.Exit(this).他的意义在于什么呢,对于任何一个对象来说,他在内存中的第一部分放置的是所有方法的地址,第二部分放着一个索引,他指向CLR中的SyncBlock Cache区域中的一个SyncBlock.什么意思呢?就是说,当你执行Monitor.Enter（Object）时，如果object的索引值为负数，就从SyncBlock Cache中选区一个SyncBlock，将其地址放在object的索引中。这样就完成了以object为标志的锁定，其他的线程想再次进行Monitor.Enter(object)操作，将获得object为正数的索引，然后就等待。直到索引变为负数，即线程使用Monitor.Exit（object)将索引变为负数。

       如果明白了Monitor.Enter的原理,lock当然不再话下.当然lock后括号里面的值不是说把整个对象锁住,而是对他的一个值进行了修改,使别的lock不能锁住他,这才是lock(object)的真面目.

       但在实际使用中Monitor还是不推荐,还是lock好的,Monitor需要加上很多try catch才能保证安全性,但lock却帮我们做了,而且lock看起来更优雅.

       在静态方法中如何使用lock呢,由于我们没有this可用,所以我们使用typeof(this)好了,Type也有相应的方法地址和索引,所以他也是可以来当作lock的标志的.

       但微软不提倡是用public的object或者typeof()或者字符串这样的标志就是因为,如果你的public object在其他的线程中被null并被垃圾收集了,将发生不可预期的错误.

KiMoGiGi 2008-06-13 22:56 发表评论

]]>

废话就不多讲了，直接看看下面的例子。
1）static int Test()
        {
            int val = 1;
            try
            {
                return val;
            }
            finally
            {
                val = 2;
            }
        }
2）static int s_val;
        static int Test()
        {
            s_val = 1;
            try
            {
                return s_val;
            }
            finally
            {
                s_val = 2;
            }
        }
请问这两个例子最后的 return value 是什么？
     我们仔细看看这两个了例子就知道2)与1）的不同在于前者使用静态变量代替局部变量。那么他们之间有什么不同么？
答案是他们的return value 是一样的，都是1。
便于讲解，我们拿出他们的IL代码看看：

本系列的全部源代码及二进制文件可以从这里下载：IocInCSharp.rar

你真的了解Ioc与AOP吗？（1）

你真的了解Ioc与AOP吗？（2）

你真的了解Ioc与AOP吗？（3）

你真的了解Ioc与AOP吗？（4）

你真的了解Ioc与AOP吗？（5）

本部分示例代码请参考"src\Step1"、"src\Step2"目录

你真的了解Ioc与AOP吗？我现在还不是很了解，而且越学习越发现自己了解的很少，Ioc与AOP中蕴涵了大量的能量等待我们去开发。在这个系列中，我仅仅利用Sping.net这个框架向大家展示一下Ioc与AOP的强大功能（呵呵，其实写这段话的目的是因为“文章题目”牛皮吹得有点大了，给自己个台阶下罢了）。

在这个系列中一共包含6个案例，从简单到复杂，也是对问题分解、思考和解决的一个过程，它们分别是：（1）类之间的依赖；（2）接口依赖；（3）基于配置文件和Reflection的工厂模式；（4）使用Spring.net实现Ioc；（5）Romoting；（6）利用Ioc在不动一行代码的情况下实现Remoting。为了更好的理解文中的内容，最好顺序阅读。

作为一个应用系统，代码复用至关重要。如果在你的设计中，类与类存在很强的相互关联，那么你会发现在重用这些组件时就存在很严重的问题。在Step1到Step3-Reflection的例子中，我们试图 利用“针对接口编程”以及自己设计的Ioc对系统进行解耦。在Step3到Step5的例子中，我们将利用Spring.net提供的Ioc框架，轻松完成解耦以及系统改造等工作。