winform跨线程问题（有参数和无参数）

1.invoke是同步线程

 using System;
 using System.Collections.Generic;
 using System.ComponentModel;
 using System.Data;
 using System.Drawing;
 using System.Linq;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 using System.Windows.Forms;

 namespace xiancheng
 {
     public partial class Form1 : Form
     {
         public Form1()
         {
             InitializeComponent();
         }
         Thread thread;
         private void Form1_Load(object sender, EventArgs e)
         {
             thread = new Thread(new ThreadStart(activeChange));
             thread.IsBackground = true;
             thread.Start();

         }
         public void activeChange()  //无参
         {
             while(true)
             {
                 if (this.InvokeRequired)
                 {
                     Action<string> changetime = (str) => { label1.Text = str; };   

                     label1.Invoke(changetime, DateTime.Now.ToString());
                 }
                 else
                 {
                     label1.Text = DateTime.Now.ToString();
                 }
             }
         }
     }
 }

简单无参的跨线程

2.delegate定义线程，和1相似，通过委托安全调用

 using System;
 using System.Collections.Generic;
 using System.ComponentModel;
 using System.Data;
 using System.Drawing;
 using System.Linq;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 using System.Windows.Forms;

 namespace xiancheng2
 {
     public partial class Form1 : Form
     {
         public Form1()
         {
             InitializeComponent();
         }
         public delegate void SetTextHandler(string result);
         private void Form1_Load(object sender, EventArgs e)
         {
             Thread th1 = new Thread(new ThreadStart(CalNum));
             th1.IsBackground = true;//不设置的话会报错：无法访问已释放的对象
             th1.Start();
         }
         private void CalNum()
         {
             while(true)
             {
                 SetCalResult(DateTime.Now.ToString());
             }

         }
         private void SetCalResult(string result)
         {

             if (label1.InvokeRequired)
             {
                 SetTextHandler set = new SetTextHandler(SetCalResult);//委托的方法参数应和SetCalResult一致  

                 label1.Invoke(set, new object[] { result });//此方法第二参数用于传入方法,代替形参result
             }
             else
             {
                 label1.Text = result;
             }

         }
     }
 }

delegate

3.BackgroundWorker

BackgroundWorker 可以用于启动后台线程。

主要的事件及参数：
　　1.DoWork——当执行BackgroundWorker.RunWorkerAsync方法时会触发该事件，并且传递DoWorkEventArgs参数;

　　2.RunWorkerCompleted——异步操作完成或中途终止会触发该事件。

如果需要提前终止执行后台操作，可以调用BackgroundWorker.CancelAsync方法。

在处理DoWork事件的函数中检测BackgroundWorker.CancellationPending属性是否为true，如果是true，则表示用户已经取消了异步调用，同时将DoWorkEventArgs.Cancel属性设为true(传递给处理DoWork事件的函数的第二个参数)，这样当退出异步调用的时候，可以让处理RunWorkerCompleted事件的函数知道是正常退出还是中途退出。
　　3.ProgressChanged——操作处理中获得的处理状态变化，通过BackgroundWorker.ReportProgress(int)方法触发该事件，并且传递ProgressChangedEventArgs,其中包含了处理的百分比,这个参数在UI界面上设置progressbar控件。

主要的方法：
         1. BackgroundWorker.RunWorkerAsync——“起动”异步调用的方法有两次重载RunWorkerAsync(),RunWorkerAsync(object argument)，第二个重载提供了一个参数，可以供异步调用使用。（如果有多个参数要传递怎么办，使用一个类来传递他们吧)。调用该方法后会触发DoWork事件，并且为处理DoWork事件的函数传递DoWorkEventArg参数，其中包含了RunWorkerAsync传递的参数。在相应DoWork的处理函数中就可以做具体的复杂操作。
        2. BackgroundWorker.ReportProgress——需要在一个冗长的操作中向用户不断反馈进度，这样的话就可以调用的ReportProgress(int percent),在调用 ReportProgress 方法时，触发ProgressChanged事件。提供一个在 0 到 100 之间的整数，它表示后台活动已完成的百分比。你也可以提供任何对象作为第二个参数，允许你 给事件处理程序传递状态信息。作为传递到此过程的 ProgressChangedEventArgs 参数属性，百分比和你自己的对象（如果提供的话）均要被传递到 ProgressChanged 事件处理程序。这些属性被分别命名为 ProgressPercentage 和 UserState，并且你的事件处理程序可以以任何需要的方式使用它们。(注意：只有在BackgroundWorker.WorkerReportsProgress属性被设置为true该方法才可用)。
        3. BackgroundWorker.CancelAsync——但需要退出异步调用的时候，就调用的这个方法。但是样还不够，因为它仅仅是将BackgroudWorker.CancellationPending属性设置为true。你需要在具体的异步调用处理的时候，不断检查BackgroudWorker.CancellationPending是否为true，如果是真的话就退出。(注意：只有在BackgroundWorker.WorkerSupportsCancellation属性被设置为true该方法才可用)。

BackgroundWorker组件
在VS2005中添加了BackgroundWorker组件，该组件在多线程编程方面使用起来非常方便，然而在开始时由于没有搞清楚它的使用机制，走了不少的弯路，现在把我在使用它的过程中的经验与诸位分享一下。
    BackgroundWorker类中主要用到的有这列属性、方法和事件：
    重要属性：
    1、CancellationPending             获取一个值，指示应用程序是否已请求取消后台操作。通过在DoWork事件中判断CancellationPending属性可以认定是否需要取消后台操作（也就是结束线程）；
    2、IsBusy                          获取一个值，指示 BackgroundWorker 是否正在运行异步操作。程序中使用IsBusy属性用来确定后台操作是否正在使用中；
    3、WorkerReportsProgress           获取或设置一个值，该值指示BackgroundWorker能否报告进度更新
    4、WorkerSupportsCancellation      获取或设置一个值，该值指示 BackgroundWorker 是否支持异步取消。设置WorkerSupportsCancellation为true使得程序可以调用CancelAsync方法提交终止挂起的后台操作的请求；
    重要方法：
    1、CancelAsync         请求取消挂起的后台操作
    2、RunWorkerAsync      开始执行后台操作
    3、ReportProgress      引发ProgressChanged事件  
    重要事件：
    1、DoWork              调用 RunWorkerAsync 时发生
    2、ProgressChanged     调用 ReportProgress 时发生
    3、RunWorkerCompleted  当后台操作已完成、被取消或引发异常时发生
    另外还有三个重要的参数是RunWorkerCompletedEventArgs以及DoWorkEventArgs、ProgressChangedEventArgs。
    BackgroundWorker的各属性、方法、事件的调用机制和顺序：

从上图可见在整个生活周期内发生了3次重要的参数传递过程：
    参数传递1：此次的参数传递是将RunWorkerAsync(Object)中的Object传递到DoWork事件的DoWorkEventArgs.Argument,由于在这里只有一个参数可以传递，所以在实际应用往封装一个类，将整个实例化的类作为RunWorkerAsync的Object传递到DoWorkEventArgs.Argument；
    参数传递2：此次是将程序运行进度传递给ProgressChanged事件，实际使用中往往使用给方法和事件更新进度条或者日志信息；
    参数传递3：在DoWork事件结束之前，将后台线程产生的结果数据赋给DoWorkEventArgs.Result一边在RunWorkerCompleted事件中调用RunWorkerCompletedEventArgs.Result属性取得后台线程产生的结果。
    另外从上图可以看到DoWork事件是在后台线程中运行的，所以在该事件中不能够操作用户界面的内容，如果需要更新用户界面，可以使用ProgressChanged事件及RunWorkCompleted事件来实现。

在WinForm中经常遇到一些费时的操作界面，比如统计某个磁盘分区的文件夹或者文件数目，如果分区很大或者文件过多的话，处理不好就会造成“假死”的情况，或者报“线程间操作无效”的异常，为了解决这个问题，可以使用委托来处理，在.net2.0中还可以用BackgroundWorker类。

BackgroundWorker类是.net 2.0里新增加的一个类，对于需要长时间操作而不需要用户长时间等待的情况可以使用这个类。
注意确保在 DoWork 事件处理程序中不操作任何用户界面对象。而应该通过 ProgressChanged 和 RunWorkerCompleted 事件与用户界面进行通信。 

   using System;
   using System.Collections.Generic;
   using System.ComponentModel;
   using System.Data;
   using System.Drawing;
   using System.Linq;
   using System.Text;
   using System.Threading;
   using System.Threading.Tasks;
  using System.Windows.Forms;

  namespace backGround
  {
      public partial class Form1 : Form
      {
          private BackgroundWorker m_BackgroundWorker;
          public Form1()
          {
              InitializeComponent();

              m_BackgroundWorker = new BackgroundWorker();

              m_BackgroundWorker.WorkerReportsProgress = true;

              m_BackgroundWorker.DoWork += new DoWorkEventHandler(DoWork);

              m_BackgroundWorker.ProgressChanged += new ProgressChangedEventHandler(UpdateProgress);

              m_BackgroundWorker.RunWorkerAsync(this);
          }

          void UpdateProgress(object sender, ProgressChangedEventArgs e)
          {
              string progress = e.UserState.ToString();

              label1.Text = string.Format("{0}", progress);
          }
          private void Form1_Load(object sender, EventArgs e)
          {

          }

          void DoWork(object sender, DoWorkEventArgs e)
          {
              BackgroundWorker bw = sender as BackgroundWorker;

              while (true)
              {
                  bw.ReportProgress(,DateTime.Now);
                  Thread.Sleep();
              }
          }

      }
  }

BackroundWorker

4.带单个参数的跨线程

 using System;
 using System.Collections.Generic;
 using System.ComponentModel;
 using System.Data;
 using System.Drawing;
 using System.Linq;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 using System.Windows.Forms;

 namespace paramWinform
 {
     public partial class Form1 : Form
     {
         public Form1()
         {
             InitializeComponent();
         }

         private void Form1_Load(object sender, EventArgs e)
         {           

         }
         private void Calculate(object o)  //必须写成object类型
         {
             if (textBox1.InvokeRequired)
             {
                 Action<string> sum = (s) => { textBox1.Text = s; };
                 textBox1.Invoke(sum, Convert.ToString(Convert.ToInt32(o) * ));
             }
             else
             {
                 textBox1.Text = Convert.ToString(o);
             }
         }

         private void button1_Click(object sender, EventArgs e)
         {
             ParameterizedThreadStart threadStart = new ParameterizedThreadStart(Calculate);
             Thread thread = new Thread(threadStart);
             thread.Start();
         }
     }
 }

5.带多个参数的

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            MyThread mt = new MyThread("", ""); //构造函数传参

            Thread th = new Thread(new ThreadStart(mt.C));
            th.IsBackground = true;
            th.Start();
            Console.ReadKey();
        }
    }
}
-----------------------------------------------------
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication1
{
    public class MyThread
    {
        public MyThread(string x,string y)
        {
            A = x;
            B = y;
        }
        string a;
        public string A
        {
            get { return a; }
            set { a = value; }
        }
        string b;
        public string B
        {
            get { return b; }
            set { b = value; }
        }

        public void C()
        {
            Console.WriteLine("这是{0},那是{1}", A, B);
        }
    }
}