如果你从非创建这个控件的线程中访问这个控件或者操作这个控件的话就会抛出这个异常。这是微软为了保证线程安全以及提高代码的效率所做的改进，但是也给大家带来很多不便。
其实解决这个问题有两种方法：
一，是通过设置
System.Windows.Forms.Control.CheckForIllegalCrossThreadCalls = false;
在你的程序初始化的时候设置了这个属性，而且在你的控件中使用的都是微软Framework类库中的控件的话，系统就不会再抛出你上面所说的这个错误了。
二，就是委托了，个人建议用这种方法
首先在WinForm窗体中拖入ListBox控件，然后参照以下代码：
Thread t1;//声明一个全局线程
private void Form1_Load(object sender, EventArgs e)
{
t1 = new Thread(new ThreadStart(BackgroundProcess));
t1.Start(); //开始
}
delegate void aa();
private void BackgroundProcess()
{
// 将委托实例化
aa a= delegate()
{
for (int i = 0; i < 50; i++)
{
listBox1.Items.Add("Iterations: " + i.ToString());
Thread.Sleep(300);
listBox1.Refresh();
}
};
listBox1.Invoke(a);
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
namespace MultiThread
{
class Program
{
int interval = 200;
static void Main(string[] args)
{
#region //测试不带参数的启动方法
//Program p = new Program();
//Thread nonParameterThread = new Thread(
// new ThreadStart(p.NonParameterRun));
//nonParameterThread.Start();
#endregion
#region //测试带参数的启动方法
//Program p = new Program();
//Thread parameterThread = new Thread(
// new ParameterizedThreadStart(p.ParameterRun));
//parameterThread.Name = "ThreadA:";
////这个值为30的int类型变量被装箱成object
//parameterThread.Start(30);
#endregion
#region //测试启动两个线程，每个线程的暂停间隔不一样
Program p = new Program();
//启动第一个线程
Thread parameterThread = new Thread(
new ParameterizedThreadStart(p.ParameterRun));
parameterThread.Name = "ThreadA:";
parameterThread.Start(30);
//启动第二个线程
parameterThread = new Thread(
new ParameterizedThreadStart(p.ParameterRun));
parameterThread.Name = "ThreadB:";
parameterThread.Start(60);
//输出为:
//说明线程是交叉运行的
//ThreadA:系统当前时间毫秒值：15
//ThreadB:系统当前时间毫秒值：15
//ThreadA:系统当前时间毫秒值：93
//ThreadB:系统当前时间毫秒值：125
//ThreadA:系统当前时间毫秒值：125
//ThreadA:系统当前时间毫秒值：156
//ThreadB:系统当前时间毫秒值：187
//ThreadA:系统当前时间毫秒值：187
//ThreadA:系统当前时间毫秒值：218
//ThreadB:系统当前时间毫秒值：250
//ThreadA:系统当前时间毫秒值：250
//ThreadA:系统当前时间毫秒值：281
//ThreadB:系统当前时间毫秒值：312
//ThreadA:系统当前时间毫秒值：312
//ThreadA:系统当前时间毫秒值：343
//ThreadB:系统当前时间毫秒值：375
//ThreadB:系统当前时间毫秒值：437
//ThreadB:系统当前时间毫秒值：500
//ThreadB:系统当前时间毫秒值：562
//ThreadB:系统当前时间毫秒值：625
#endregion
Console.ReadLine();
}
///
///不带参数的启动方法
///
public void NonParameterRun()
{
for (int i = 0; i < 10; i++)
{
Console.WriteLine("系统当前时间毫秒值：" +
DateTime.Now.Millisecond.ToString());
Thread.Sleep(interval);//让线程暂停
}
}
///
///带参数的启动方法
///
///让线程在运行过程中的休眠间隔
public void ParameterRun(object ms)
{
int j=10;
//这里采用了TryParse方法，避免不能转换时出现异常
int.TryParse(ms.ToString(),out j);
for(int i=0;i<10;i++)
{
Console.WriteLine(Thread.CurrentThread.Name+"系统当前时间毫秒值："+
DateTime.Now.Millisecond.ToString());
Thread.Sleep(j);//让线程暂停
}
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
namespace ThreadTest
{
//继续探索
//上面解决了一个问题，如果在启动线程时需要参数如何解决，如果针对上面的问题继续发掘
//，比如：在启动线程时不但要指定线程的暂停间隔，还需要指定循环次数(在上面的所有例
//子中都是执行10次的)，这个问题该如何解决呢?
//有两种办法可以解决：
//首先可以继续在ParameterizedThreadStart这里做文章，因为这里可以使用一个Object类
//型的参数，那么可以通过数组或者一个类来解决(因为它们都是Object的子类)。我在做某
//个系统时确实采用数组处理过这种情况，这样就要求在线程启动方法中必须清楚知道数组
//中每个参数的用途，不是太方便。
//这里说说重新定义一个实体类来解决的方法，代码如下。
#region//第一种方法
/// <summary>
/// class MyThreadParameter
/// 只读属性:循环次数 LoopCount;线程的暂停间隔 Interval
/// </summary>
class MyThreadParameter
{
private int interval;
private int loopCount;
///
///循环次数
///
public int LoopCount
{
get{return loopCount;}
}
///
///线程的暂停间隔
///
public int Interval
{
get{return interval;}
}
///
///构造函数
///
///线程的暂停间隔
///循环次数
public MyThreadParameter(int interval,int loopCount)
{
this.interval=interval;
this.loopCount=loopCount;
}
}
class Program
{
int interval=200;
static void Main(string[] args)
{
Program p=new Program();
Thread parameterThread=new Thread(
new ParameterizedThreadStart(p.MyParameterRun));
parameterThread.Name="ThreadA:";
MyThreadParameter paramter=new MyThreadParameter(50,20);
parameterThread.Start(paramter);
Console.ReadLine();
}
///
/// ///带多个参数的启动方法
///
///方法参数
public void MyParameterRun(object ms)
{
MyThreadParameter parameter=ms as MyThreadParameter;//类型转换
if (parameter != null)
{
for (int i = 0; i < parameter.LoopCount; i++)
{
Console.WriteLine(Thread.CurrentThread.Name + "系统当前时间毫秒值："
+ DateTime.Now.Millisecond.ToString());
Thread.Sleep(parameter.Interval);//让线程暂停
}
}
}
}
#endregion
//第二种方法和上面方法有些相似，也是需要引入外部类，并且将Thread实例放在引入的类
//中，这种情况适合于在线程中处理的业务逻辑比较复杂的情况。在前不久处理的一个项目
//中我用过这种情况，它是用来实现双向数据传输的。
#region//第二种方法
//class Program
//{
// /// <summary>
// /// 用来封装一个线程
// /// 字段:循环次数 LoopCount;线程的暂停间隔 Interval;线程实例 Thread
// /// </summary>
// class MyThreadParameter
// {
// private int interval;
// private int loopCount;
// private Thread thread;
// ///
// ///构造函数
// ///
// ///线程的暂停间隔
// ///循环次数
// public MyThreadParameter(int interval, int loopCount)
// {
// this.interval = interval;
// this.loopCount = loopCount;
// thread = new Thread(new ThreadStart(Run));
// }
// public void Start()
// {
// if (thread != null)
// {
// thread.Start();
// }
// }
// private void Run()
// {
// for (int i = 0; i < loopCount; i++)
// {
// Console.WriteLine("系统当前时间毫秒值：" +
// DateTime.Now.Millisecond.ToString());
// Thread.Sleep(interval);//让线程暂停
// }
// }
// }
// static void Main(string[] args)
// {
// MyThreadParameter parameterThread = new MyThreadParameter(30, 50);
// parameterThread.Start();
// Console.ReadLine();
// }
//}
#endregion
//上面的代码的运行效果和前面的代码运行效果类似，只不过是将业务处理代码放在一个单
//独的类MyThreadParameter中，使得MyThreadParameter看起来也像一个Thread，实际上维
//护的还是其内部的Thread，在一些大型系统中这样做的好处是便于维护。
//总结：在本篇主要讲述如何启动线程的问题，在启动时可能会遇到无需参数、需要多个参
//数的情况，在这里讲述了如何解决这些问题的思路。在.net类库中虽然存在着庞大的类库
//，但是并不是总会有合适的类来解决我们所遇到的问题，但是只要肯动脑筋总会想到合适
//的办法。
近日，被Control的Invoke和BeginInvoke搞的头大，就查了些相关的资料，整理如下。
(一）Control的Invoke和BeginInvoke （1）Control的Invoke和BeginInvoke与Delegate的Invoke和BeginInvoke是不同的。
（2）Control的Invoke和BeginInvoke的参数为delegate，委托的方法是在Control的线程上执行的，也就是我们平时所说的UI线程。
我们以代码(一)来看(Control的Invoke)
private delegate void InvokeDelegate();
private void InvokeMethod(){
//C代码段 private void butInvoke_Click(object sender, EventArgs e) {
//A代码段.......
this.Invoke(new InvokeDelegate(InvokeMethod));
//B代码段...... 你觉得代码的执行顺序是什么呢?记好Control的Invoke和BeginInvoke都执行在主线程即UI线程上
A------>C---------------->B
解释：(1)A在UI线程上执行完后，开始Invoke，Invoke是同步
(2)代码段B并不执行，而是立即在UI线程上执行InvokeMethod方法，即代码段C。
(3)InvokeMethod方法执行完后，代码段C才在UI线程上继续执行。
看看代码(二)，Control的BeginInvoke
private delegate void BeginInvokeDelegate();
private void BeginInvokeMethod(){
//C代码段 private void butBeginInvoke_Click(object sender, EventArgs e) {
//A代码段.......
this.BeginInvoke(new BeginInvokeDelegate(BeginInvokeMethod));
//B代码段...... 你觉得代码的执行顺序是什么呢?记好Control的Invoke和BeginInvoke都执行在主线程即UI线程上
A----------->B--------------->C慎重，这个只做参考。。。。。，我也不肯定执行顺序，如果有哪位达人知道的话请告知。
解释：：(1)A在UI线程上执行完后，开始BeginInvoke，BeginInvoke是异步
(2)InvokeMethod方法，即代码段C不会执行，而是立即在UI线程上执行代码段B。
(3)代码段B执行完后(就是说butBeginInvoke_Click方法执行完后)，InvokeMethod方法，即代码段C才在UI线程上继续执行。 Control的Invoke和BeginInvoke的委托方法是在主线程，即UI线程上执行的。也就是说如果你的委托方法用来取花费时间长的数据，然后更新界面什么的，千万别在UI线程上调用Control.Invoke和 Control.BeginInvoke，因为这些是依然阻塞UI线程的，造成界面的假死。 异步是指相对于调用BeginInvoke的线程异步，而不是相对于UI线程异步，你在UI线程上调用BeginInvoke ，当然不行了。－－－－摘自"Invoke和BeginInvoke的真正涵义"一文中的评论。
BeginInvoke的原理是将调用的方法Marshal成消息，然后调用Win32 API中的RegisterWindowMessage()向UI窗口发送消息。－－－－摘自"Invoke和BeginInvoke的真正涵义"一文中的评论。
(二)我们用Thread来调用BeginInvoke和Invoke
我们开一个线程，让线程执行一些耗费时间的操作，然后再用Control.Invoke和Control.BeginInvoke回到用户UI线程，执行界面更新。
代码(三) Thread调用Control的Invoke
private Thread invokeThread;
private delegate void invokeDelegate();
private void StartMethod(){
//C代码段......
Control.Invoke(new invokeDelegate(invokeMethod));
//D代码段...... private void invokeMethod(){
//E代码段 private void butInvoke_Click(object sender, EventArgs e) {
//A代码段.......
invokeThread = new Thread(new ThreadStart(StartMethod));
invokeThread.Start();
//B代码段......
你觉得代码的执行顺序是什么呢?记好Control的Invoke和BeginInvoke都执行在主线程即UI线程上
A------>(Start一开始B和StartMethod的C就同时执行)---->(C执行完了，不管B有没有执行完，invokeThread把消息封送(invoke)给UI线程，然后自己等待)---->UI线程处理完butInvoke_Click消息后，处理invokeThread封送过来的消息，执行invokeMethod 方法，即代码段E，处理往后UI线程切换到invokeThread线程。
这个Control.Invoke是相对于invokeThread线程同步的，阻止了其运行。 1。UI执行A
2。UI开线程InvokeThread，B和C同时执行，B执行在线程UI上，C执行在线程invokeThread上。
3。invokeThread封送消息给UI，然后自己等待，UI处理完消息后，处理invokeThread封送的消息，即代码段E
4。UI执行完E后，转到线程invokeThread上，invokeThread线程执行代码段D
代码(四) Thread调用Control的BeginInvoke
private Thread beginInvokeThread;
private delegate void beginInvokeDelegate();
private void StartMethod(){
//C代码段......
Control.BeginInvoke(new beginInvokeDelegate(beginInvokeMethod));
//D代码段...... private void beginInvokeMethod(){
//E代码段 private void butBeginInvoke_Click(object sender, EventArgs e) {
//A代码段.......
beginInvokeThread = new Thread(new ThreadStart(StartMethod));
beginInvokeThread .Start();
//B代码段...... 你觉得代码的执行顺序是什么呢?记好Control的Invoke和BeginInvoke都执行在主线程即UI线程上
A在UI线程上执行----->beginInvokeThread线程开始执行，UI继续执行代码段B，并发地invokeThread执行代码段C-------------->不管UI有没有执行完代码段B，这时 beginInvokeThread线程把消息封送给UI，单自己并不等待，继续向下执行-------->UI处理完 butBeginInvoke_Click消息后，处理beginInvokeThread线程封送过来的消息。 解释：
1。UI执行A
2。UI开线程beginInvokeThread，B和C同时执行，B执行在线程UI上，C执行在线程beginInvokeThread上。
3。beginInvokeThread封送消息给UI，然后自己继续执行代码D，UI处理完消息后，处理invokeThread封送的消息，即代码段E
有点疑问：如果UI先执行完毕，是不是有可能过了段时间beginInvokeThread才把消息封送给UI，然后UI才继续执行封送的消息E。如图浅绿的部分。
Control的BeginInvoke是相对于调用它的线程，即beginInvokeThread相对是异步的。 (1)如果你想阻止调用线程，那么调用代码(三)，代码段D删掉，C改为耗费长时间的操作，因为这个操作是在另外一个线程中做的。代码段E改为更新界面的方法。
(2)如果你不想阻止调用线程，那么调用代码(四)，代码段D删掉，C改为耗费长时间的操作，因为这个操作是在另外一个线程中做的。代码段E改为更新界面的方法。
提供一个解决方案，答案是在成员类上，我们对UserInfo类做如下改动 public class UserInfo
{
private string _name;
///
/// 用户名称
///
public string Name
{
get { return _name; }
set { _name = value; }
}
private string _workDetail;
///
/// 代码细节 可以理解为代码分工，这个属性里我们对CrazyCoder工作室成员进行工作分工
/// by crazycoder http://www.crazycoder.cn
///
public string WrokDetail
{
get { return _workDetail; }
set { _workDetail = value; }
} ///
/// 线程执行具体方法 注意:必须是Void类型，不能为静态方法
/// 这里实现了线程分工
/// by crazycoder http://www.crazycoder.cn
///
public void Work()
{
//这里写要做的工作代码
if (_workDetail == "负责写数据操作类代码")
{
//开始写底层代码
}
else
{
//这里写其他判断语句
}
}
}同样我们对线程类改造 ///
/// C#多线程系列教程 疯狂代码工作室出品
/// by crazycoder http://www.crazycoder.cn
///
public class CrazyCoderThread
{
///
/// 线程执行代码
/// by crazycoder http://www.crazycoder.cn
///
public void ProjectThread()
{
//假设工作室6名成员开始工作
for (int i = 1; i <= 6; i++)
{
UserInfo u = new UserInfo();
u.Name = "疯狂工作室成员" + i.ToString();
//这里对线程成员分工
u.WrokDetail = "负责写数据操作类代码";
//线程初始化
Thread t = new Thread(u.Work);
//线程开始
t.Start();
}
}
}
到这里，我们已经可以实现对线程的分工了，希望能给大家帮助
道理很简单，我们就是在代码定义的时候对线程进行了分工
