(3).C#线程的参数传递

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

 

用C#创建线程是一件很方便的事，一个Void类型的函数，一句声明就可以创建出自己的线程应用。看下面的例子：

publicclass ThreadController
    {
        public ThreadController()
        {
            System.Threading.Thread thread =new System.Threading.Thread(ThreadMethod);
            thread.Start();
        }

        privatevoid ThreadMethod()
        {
            //Do something
        }
    }

 

 

 

方式一：使用ParameterizedThreadStart委托

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

不过从上面的例子可以看到一个问题，就是ThreadMethod方法是不能传入参数的。要解决这个问题，需要用到ParameterizedThreadStart。看这个例子：

publicclass ThreadController
{
public ThreadController()
{
int value =10;
System.Threading.Thread thread =new System.Threading.Thread(new System.Threading.ParameterizedThreadStart(ThreadMethod));
thread.Start(value);
}

privatevoid ThreadMethod(object parameter)
{
Console.WriteLine(parameter.ToString());
}
}

 publicclass ThreadController
    {
        public ThreadController()
        { 
            int value =10;
　　　　　　　// A_Point 使用ParameterizedThreadStart委托，并调用Start(参数对象)
            System.Threading.Thread thread =new System.Threading.Thread(new System.Threading.ParameterizedThreadStart(ThreadMethod));
            thread.Start(value);
        }

        privatevoid ThreadMethod(object parameter)
        {
            Console.WriteLine(parameter.ToString());
        }
    }

using System;
using System.Threading;
namespace ThreadWithParameters{

    class Program
    {
        static void Main(string[] args)
        {
            string hello = "hello world"; 
           //A_Point 这里也可简写成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委托的声明

这样线程的响应函数就可以接收参数了。这里还有一个要注意的问题，就是作为参数传递进来的parameter，虽然在参数描述上没有加Ref，但实际上是传地址的引用。所以如果在ThreadMethod中对parameter进行修改。ThreadController中的value值也会被修改。

 

方式二：创建自定义类

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

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();
        }
    }
}

对这种方法也不是很满意，总不能一遇到比较耗时的方法，就新建一个类吧。那有什么更好办法即不用强制类型转换，也不用新建一个类呢?

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

方式三：利用lambda表达式

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反编译了一下，确实如他所说，我所谓的第三种方式其实和第二种方式是一样的，只不过自定义类编译器帮我们做了。