C#实现向多线程传参的三种方式实例分析

本文实例讲述了c#实现向多线程传参的三种方式。分享给大家供大家参考，具体如下：

从《c#高级编程》了解到给线程传递参数有两种方式，一种方式是使用带parameterizedthreadstart委托参数的thread构造函数，另一种方式是创建一个自定义类，把线程的方法定义为实例的方法，这样就可以初始化实例的数据，之后启动线程。

方式一：使用parameterizedthreadstart委托

如果使用了parameterizedthreadstart委托，线程的入口必须有一个object类型的参数，且返回类型为void。且看下面的例子：

using system;
using system.threading;
namespace threadwithparameters
{
  class program
  {
    static void main(string[] args)
    {
      string hello = "hello world";
      //这里也可简写成thread thread = new thread(threadmainwithparameters);
      //但是为了让大家知道这里用的是parameterizedthreadstart委托，就没有简写了
      thread thread = new thread(new parameterizedthreadstart(threadmainwithparameters));
      thread.start(hello);
      console.read();
    }
    static void threadmainwithparameters(object obj)
    {
      string str = obj as string;
      if(!string.isnullorempty(str))
        console.writeline("running in a thread,received: {0}", str);
    }
  }
}

这里稍微有点麻烦的就是threadmainwithparameters方法里的参数必须是object类型的，我们需要进行类型转换。为什么参数必须是object类型呢，各位看看parameterizedthreadstart委托的声明就知道了。

public delegate void parameterizedthreadstart(object obj);   //parameterizedthreadstart委托的声明

方式二：创建自定义类

定义一个类，在其中定义需要的字段，将线程的主方法定义为类的一个实例方法，说得不是很明白，还是看实际的例子吧。

using system;
using system.threading;
namespace threadwithparameters
{
  public class mythread
  {
    private string data;
    public mythread(string data)
    {
      this.data = data;
    }
    public void threadmain()
    {
      console.writeline("running in a thread,data: {0}", data);
    }
  }
  class program
  {
    static void main(string[] args)
    {
      mythread mythread = new mythread("hello world");
      thread thread = new thread(mythread.threadmain);
      thread.start();
      console.read();
    }
  }
}

对这种方法也不是很满意，总不能一遇到比较耗时的方法，就新建一个类吧。。。

那有什么更好办法即不用强制类型转换，也不用新建一个类呢？

下面就介绍下我无意中找到的一个方法，具体是在哪见过的我也不记得了，罪过啊。。

方式三：使用匿名方法

using system;
using system.threading;
namespace threadwithparameters
{
  class program
  {
    static void main(string[] args)
    {
      string hello = "hello world";
      //如果写成thread thread = new thread(threadmainwithparameters(hello));这种形式，编译时就会报错
      thread thread = new thread(() => threadmainwithparameters(hello));
      thread.start();
      console.read();
    }
    static void threadmainwithparameters(string str)
    {
       console.writeline("running in a thread,received: {0}", str);
    }
  }
}

哇，你会发现既不用类型强制转换也不用新建类就运行成功了。

但是为什么这种方式能行呢，根据昨天 @乱舞春秋 的提示，我也用ildasm反编译了一下，确实如他所说，我所谓的第三种方式其实和第二种方式是一样的，只不过自定义类编译器帮我们做了。

下面的是第三种方式main方法反编译的il代码：

.method private hidebysig static void main(string[] args) cil managed
{
  .entrypoint
  // 代码大小    51 (0x33)
  .maxstack 3
  .locals init ([0] class [mscorlib]system.threading.thread thread,
       [1] class threadwithparameters.program/'<>c__displayclass1' 'cs$<>8__locals2')
  il_0000: newobj   instance void threadwithparameters.program/'<>c__displayclass1'::.ctor()
  il_0005: stloc.1
  il_0006: nop
  il_0007: ldloc.1
  il_0008: ldstr   "hello world"
  il_000d: stfld   string threadwithparameters.program/'<>c__displayclass1'::hello
  il_0012: ldloc.1
  il_0013: ldftn   instance void threadwithparameters.program/'<>c__displayclass1'::'<main>b__0'()
  il_0019: newobj   instance void [mscorlib]system.threading.threadstart::.ctor(object, native int)
  il_001e: newobj   instance void [mscorlib]system.threading.thread::.ctor(class [mscorlib]system.threading.threadstart)
  il_0023: stloc.0
  il_0024: ldloc.0
  il_0025: callvirt  instance void [mscorlib]system.threading.thread::start()
  il_002a: nop
  il_002b: call    int32 [mscorlib]system.console::read()
  il_0030: pop
  il_0031: nop
  il_0032: ret
} // end of method program::main

在看看第二种方式的il代码：

.method private hidebysig static void main(string[] args) cil managed
{
  .entrypoint
  // 代码大小    44 (0x2c)
  .maxstack 3
  .locals init ([0] class threadwithparameters.mythread mythread,
       [1] class [mscorlib]system.threading.thread thread)
  il_0000: nop
  il_0001: ldstr   "hello world"
  il_0006: newobj   instance void threadwithparameters.mythread::.ctor(string)
  il_000b: stloc.0
  il_000c: ldloc.0
  il_000d: ldftn   instance void threadwithparameters.mythread::threadmain()
  il_0013: newobj   instance void [mscorlib]system.threading.threadstart::.ctor(object, native int)
  il_0018: newobj   instance void [mscorlib]system.threading.thread::.ctor(class [mscorlib]system.threading.threadstart)
  il_001d: stloc.1
  il_001e: ldloc.1
  il_001f: callvirt  instance void [mscorlib]system.threading.thread::start()
  il_0024: nop
  il_0025: call    int32 [mscorlib]system.console::read()
  il_002a: pop
  il_002b: ret
} // end of method program::main

比较两端代码，可以发现两者都有一个newobj，这句的作用是初始化一个类的实例，第三种方式由编译器生成了一个类：c__displayclass1

il_0000: newobj   instance void threadwithparameters.program/'<>c__displayclass1'::.ctor()
il_0006: newobj   instance void threadwithparameters.mythread::.ctor(string)

注意：简单并不一定是好事，匿名方法容易造成不易察觉的错误

希望本文所述对大家c#程序设计有所帮助。