Net线程足迹传递参数至线程-阿里云开发者社区

Net线程足迹传递参数至线程

2017-07-31 922

版权

本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。

简介：

方法一：应用ParameterizedThreadStart这个委托来传递输入参数，这种方法适用于传递单个参数的情况。

 
    [c-sharp] 
    view plain
    copy 
   
using System;  
using System.Collections.Generic;  
using System.ComponentModel;  
using System.Data;  
using System.Drawing;  
using System.Linq;  
using System.Text;  
using System.Windows.Forms;  
using System.Threading;  
  
namespace BeginInvokeTest  
{  
    /// <summary>  
    /// 给线程传递参数  
    /// </summary>  
    public partial class Form1 : Form  
    {  
        public Form1()  
        {  
            InitializeComponent();  
        }  
  
        private void button1_Click(object sender, EventArgs e)  
        {  
            //第一种方法，应用ParameterizedThreadStart这个委托来传递输入参数  
            ParameterizedThreadStart start = new ParameterizedThreadStart(ChangeText);  
            Thread thread = new Thread(start);  
            object obj = "HelloWorld";  
            thread.Start(obj);  
        }  
  
        public delegate void ChangeTextDelegate(object message);  
  
        public void ChangeText(object message)  
        {  
            //InvokeRequired是Control的一个属性（这个属性是可以在其他线程里访问的）  
            //这个属性表明调用方是否来自非UI线程,如果是,则使用BeginInvoke来调用这个函数,否则就直接调用,省去线程封送的过程  
            if (this.InvokeRequired)  
            {  
                this.BeginInvoke(new ChangeTextDelegate(ChangeText), message);  
            }  
            else  
            {  
                this.Text = message.ToString();  
            }  
        }  
  
    }  
}  

ParameterizedThreadStart 委托和 Thread.Start(Object) 方法重载使得将数据传递给线程过程变得简单，但由于可以将任何对象传递给 Thread.Start(Object)，因此这种方法并不是类型安全的。将数据传递给线程过程的一个更可靠的方法是将线程过程和数据字段都放入辅助对象。因此第一种方法是不推荐的。

方法二：利用线程实现类，将调用参数定义成属性的方式来操作线程参数，也就是将线程执行的方法和参数都封装到一个类里面。通过实例化该类，方法就可以调用属性来实现间接的类型安全地传递参数。通过之种方法可以传递多个参数。

 
    [c-sharp] 
    view plain
    copy 
   
using System;  
using System.Threading;  
  
// The ThreadWithState class contains the information needed for  
// a task, and the method that executes the task.  
//  
public class ThreadWithState {  
    // State information used in the task.  
    private string boilerplate;  
    private int value;  
  
    // The constructor obtains the state information.  
    public ThreadWithState(string text, int number)   
    {  
        boilerplate = text;  
        value = number;  
    }  
  
    // The thread procedure performs the task, such as formatting   
    // and printing a document.  
    public void ThreadProc()   
    {  
        Console.WriteLine(boilerplate, value);   
    }  
}  
  
// Entry point for the example.  
//  
public class Example {  
    public static void Main()   
    {  
        // Supply the state information required by the task.  
        ThreadWithState tws = new ThreadWithState(  
            "This report displays the number {0}.", 42);  
  
        // Create a thread to execute the task, and then  
        // start the thread.  
        Thread t = new Thread(new ThreadStart(tws.ThreadProc));  
        t.Start();  
        Console.WriteLine("Main thread does some work, then waits.");  
        t.Join();  
        Console.WriteLine(  
            "Independent task has completed; main thread ends.");    
    }  
}  

上面示例摘自MSDN

方法三：利用线程池来传递参数

方法四：利用匿名方法来传递参数，利用了匿名方法,连上面那种独立的类都省掉了，但是如果逻辑比较复杂，用这种方法就不太好了。

 
    [c-sharp] 
    view plain
    copy 
   
using System;  
using System.Collections.Generic;  
using System.ComponentModel;  
using System.Data;  
using System.Drawing;  
using System.Linq;  
using System.Text;  
using System.Windows.Forms;  
using System.Threading;  
  
namespace BeginInvokeTest  
{  
    public partial class Form2 : Form  
    {  
        public Form2()  
        {  
            InitializeComponent();  
        }  
  
        private void button1_Click(object sender, EventArgs e)  
        {  
            Thread thread = new Thread(new ThreadStart(delegate()  
            {  
                this.BeginInvoke(new ChangeTextDelegate(ChangeText), "HelloWorld");  
            }));  
            thread.Start();  
        }  
  
        public delegate void ChangeTextDelegate(string message);  
        public void ChangeText(string message)  
        {  
            this.Text = message;  
        }  
    }  
}  

此外，如果需要从线程返回数据，这时可以用回调方法，下面示例摘自MSDN。

 
    [c-sharp] 
    view plain
    copy 
   

    using System;  
using System.Threading;  
  
// The ThreadWithState class contains the information needed for  
// a task, the method that executes the task, and a delegate  
// to call when the task is complete.  
//  
public class ThreadWithState {  
    // State information used in the task.  
    private string boilerplate;  
    private int value;  
  
    // Delegate used to execute the callback method when the  
    // task is complete.  
    private ExampleCallback callback;  
  
    // The constructor obtains the state information and the  
    // callback delegate.  
    public ThreadWithState(string text, int number,   
        ExampleCallback callbackDelegate)   
    {  
        boilerplate = text;  
        value = number;  
        callback = callbackDelegate;  
    }  
      
    // The thread procedure performs the task, such as  
    // formatting and printing a document, and then invokes  
    // the callback delegate with the number of lines printed.  
    public void ThreadProc()   
    {  
        Console.WriteLine(boilerplate, value);  
        if (callback != null)  
            callback(1);  
    }  
}  
  
// Delegate that defines the signature for the callback method.  
//  
public delegate void ExampleCallback(int lineCount);  
  
// Entry point for the example.  
//  
public class Example   
{  
    public static void Main()   
    {  
        // Supply the state information required by the task.  
        ThreadWithState tws = new ThreadWithState(  
            "This report displays the number {0}.",  
            42,  
            new ExampleCallback(ResultCallback)  
        );  
  
        Thread t = new Thread(new ThreadStart(tws.ThreadProc));  
        t.Start();  
        Console.WriteLine("Main thread does some work, then waits.");  
        t.Join();  
        Console.WriteLine(  
            "Independent task has completed; main thread ends.");   
    }  
  
    // The callback method must match the signature of the  
    // callback delegate.  
    //  
    public static void ResultCallback(int lineCount)   
    {  
        Console.WriteLine(  
            "Independent task printed {0} lines.", lineCount);  
    }  
}  