c多线程访问控件

① C#多线程问题：线程间操作无效: 从不是创建控件“label4”的线程访问它。

一楼正解

你是写在GuidProc这个类里面的,这个是不行的.必须写在Form的类中或者子类中.就是说:this.Invoke中的this必须指的是一个窗体对象.

补充:
原因:声明的委托需要参数.
private delegate void SetTextDelegate(string value);

解决:修改代码.

if (this.InvokeRequired)
{
SetLabelText d = new SetLabelText(SetLabel1);
object arg = (object)要传入的参数值
this.Invoke(d,arg);//这里参数不对。
}

② 请教c#多线程操作更新控件的简便方法

char*c[]={"ENTER","NEW","POIT","FIRST"};//指针数组，数组的每个元素是指针，这里存常量字符串的首地址。char**cp[]={c+3,c+2,c+1,c};//二级指针数组，数组每个元素是二级指针，这里存了c[3].c[2],c[1],c[0]的地址,也就是上面字符串顺序逆序char***cpp=cp;三级指针指向cp数组首地址。ps，一般三级指针在正常的程序里不会出现，容易形成非常混乱的局面。printf("%s\n",**++cpp);POIT//优先级相同，临近原则++cpp--->c+2的地址,两次间址是POITprintf("%s\n,",*--*++cpp);ENTER//++cpp--->cp+1（上面自增过了），间址一次变成cp[1]，--c+1再间地址，就是c第一个元素。ENTER。printf("%s\n",*cpp[-2]+3);ST//cpp指向c+1的位置。cpp[-2]就是*(cpp-2)指向cp+0,就是c+3*(c+3)+3不就是FIRST数第四个字母么，后面输出ST。printf("%s\n",cpp[-1][-1]+1);上面cpp还是指向在c+1,*(cpp-1)是c+2,*(*c+2-1)--->c+1,NEW这个单词地址，*((*(c+1))+1)数到E往后输出}

③ VC多线程中控制界面控件的几种方法

MFC本身不是线程安全的，最好不要在线程中操作UI。如果不得不这么做，首先确保自己能做好同步。然后方法还是很多的。

• 发送消息。虽然操作UI可能会导致问题，但是发送消息却不会，利用消息启动实例的响应函数，然后从共享数据里取出数据进行操作。

• 把实例的句柄传给线程。在保证同步的情况下操作实例的方法。

④ VCL中的控件直接支持多线程吗

因为你写的程序是独占模式，而不是应用线程。瑞星杀毒时，点击别的菜单仍然有反应，是因是杀毒过程是另一个线程，WIN 98/NT/2000/XP 是个多任务操作系统，也就是：一个进程可以划分为多个线程，每个线程轮流占用CPU 运行时间和资源，或者说，把CPU时间划成片，每个片分给不同的线程，这样，每个线程轮流的“挂起”和“唤醒”，由于时间片很小，给人的感觉是同时运行的。

下面是自己找的一些资料，你参考一下：

多线程带来如下好处：（自己阅读）

1）避免瓶颈；

2）并行操作；

3）提高效率；

在多线程中，通过优先级管理，可以使重要的程序优先操作，提高了

任务管理的灵活性。

另一方面，在多CPU 系统中，可以把不同的线程在不同的CPU 中执行，

真正做到同时处理多任务（Win 98 只是模拟的，而Win/NT/2000是真正的

多CPU同时操作）。

多线程的两个概念：

1） 进程：也称任务，程序载入内存，并分配资源，称为“一个进程

”。注意：进程本身并不一定要正在执行。进程由以下几部分组成：

a>一个私有的地址空间，它是进程可以使用的一组虚拟内存地址空间；

b>程序的相关代码、数据源；

c>系统资源，比如操作系统同步对象等；

d>至少包含一个线程（主线程）；

2） 线程：是程序的执行单位（线程本身并不包括程序代码，真正拥

有代码的是进程），每个进程至少包括一个线程，称为主线程，一个进程

如果有多个线程，就可以共享同一进程的资源，并可以并发执行。

线程是进程的一个执行单元，是操作系统分配CPU 时间的基本实体，

线程主要由如下两部分组成：

a>数据结构；

b>CPU 寄存器和堆栈；

一个进程中的线程，可以独立运行，也可以控制另一个线程的运行。

请注意：

多线程不能滥用，书上提到了多线程的几个缺点（自阅）。

2-2 Tthread 对象

虽然Windows 提供了比较多的多线程设计的API 函数，但是直接使用

API 函数一方面极其不方便，而且使用不当还容易出错。为解决这个问题，

Borland 公司率先推出了一种Tthread 对象，来解决多线程设计上的困难，

简化了多线程问题的处理。

应该注意，Tthread 对象是没有实例的，它和界面的交流，主要依靠

主窗体（主VCL线程），这和其他对象使用上有些区别。

一、Tthread 对象的主要方法

构造线程：

constructor Create(CreateSuspended:boolean)

其中：CreateSuspended=true 构造但不唤醒

false 构造的同时即唤醒

也可以用如下方法

inheried Create(CreateSuspended:boolean)

挂起线程：

suspend

（把线程挂起的次数加一）

唤醒线程：

resume

（注意：注意这个属性是把线程挂起的次数减一，当次数为0 时，

即唤醒。也就是说，线程挂起多少次，唤醒也需要多少次。同时挂起

的时候将保持线程的地址指针不变，所以线程挂起后再唤醒，将从挂

起的地方开始运行）

析构（清除线程所占用的内存）：

destroy

终止线程（后面会具体讨论）:

Terminate

二、线程应用的简单例子：

下面通过一个例子说明上述方法的应用。我们知道，循环是独占

性最强的运行方式之一，现在希望建立两个线程对象，实现循环的并

行运行。具体方法如下：

File---New---Thread Object

这就自动在主Form中建立了一个线程单元（在对话框里写上线程名

字），默认的名字是Unit2。同样方法建立第二个线程单元Unit3。

要注意的是：Unit2和Unit3中有一个给定的过程：

procere Object.Execute;

begin

end;

其中的程序是线程唤醒后自动执行的程序，也可以在里面调用其

他自定义的过程和函数。这个过程的结束，意味着线程程序的结束。

为了构造线程，在interface的Type区，定义一个构造过程：

type

Object = class(TThread) //自动给出的，也可以直接改

private

protected

procere Execute; override;

public

constructor create; //自己写的

并且在implementation区域写上：

constructor Object.create;

begin

inherited create(true);

end

其中Object 为线程对象的名字。所以这么写，是希望在主Form中

调用这个构造过程。

Create()的参数用True，表明构造出的线程为挂起状态。

注意一下，在同一个线程对象里，如果两次构造，将产生两个独立

的线程，不但运行是独立的，而且使用线程的局部变量也是独立的。但

这里为了简化问题，还是建立了两个独立的线程对象，而且两个循环数

是不同的，在并行运算时容易判断出是两个不同的程序在运行。

假定我们给两个线程对象起的名字是：

mymath1

mymath2

这样在Unit1，应该作如下声明：

implementation

uses unit2,unit3;

var thread1:mymath1;

thread2:mymath2;

这样在主线程，将可以通过这两个线程变量调用对应的线程方法。

在主线程区构造线程的方法是：

thread1:=mymath1.create;

thread2:=mymath2.create;

挂起：

thread1.suspend;

thread2.suspend;

唤醒：

thread1.resume;

thread2.resume;

析构：

thread1.destroy;

thread2.destroy;

这里需要说明的是，由于线程单元需要调用Form的Edit控件（对象），

可以采用两种方法：

1） 在线程单元定义一个TEdit对象，例如

edit4:Tedit;

在Execute过程内直接引用

但在Unit1中一定要在FormCreate过程里作一个赋值：

procere TForm1.FormCreate(Sender: TObject);

begin

thread1.edit4:=edit1;

end;

这样，就把第一线程的edit4与Form上的edit1联系来。

2）在第二个线程中首先声明调用Unti1，也就是要加上

Uses Unit1;

这样就可以在该线程单元直接调用主Form的控件了，比如在Unit3中

可以写：

form1.edit2.text:=inttostr(i)

了解了这些基本规则，就可以写出比较复杂的多线程程序了。

还有一点要说明的，默认生成的线程单元，调用的单元只有一个：

Uses Classes;

这样，往往很多函数和对象在线程单元里不能使用，所以在必要时，

应该根据需要User相应的单元，这个例程为了简单，把大部分常用的单

元都拷过去了，这并不是推荐的办法，因为这样一来会使程序的垃圾过

多，所以，一般要用什么拷什么。

三、常用的API 函数

在处理多线程问题的时候,也经常用到Windows提供的API 函数，需

要说明的是，Tthread 对象内部封装的方法，其实主要也是调用API 函

数，但是，考虑更全面，更安全。而直接调用API 函数，往往会因为运

用不当，出现一些不应有的错误。所以，我个人以为，只要用Tthread

对象的方法能解决的，就不要直接调用API 函数，API 函数只应该在用

在Tthread 对象方法解决不了的时候。

例如Tthread 对象方法内部调用API 函数的时候，一般使用推荐的

默认值，但需要更精细的控制时，就可以直接使用API 函数。

其实，Tthread 对象方法已经受到了大多数程序设计者的认可，比

如，原来VB是不具备直接处理多线程的能力的，但是，现在VB.Net就宣

称，它具备了简单处理多线程问题的能力，这就很说明问题。

下面简单介绍几种API 函数，为了清晰方便，这里着重在于说明，

函数正确的描述可以自己阅读书上的例子和手册：

构建线程：

CreateThread(参数1，--安全属性（一般=Nil，默认安全属性）

参数2，--线程堆栈尺寸（一般=0，与主线程相同长

度，而且可以根据需要自动变化）

参数3，--指向函数名指针，@函数名，这个参数十

分重要，不正确将无法调用成功。

参数4，--用户需要向线程传递的参数，是一个指向

结构的指针，不需传递参数时，为Nil。

参数5）--传入与线程有关的一些参数，例如：

CREATE_SUSPENDED 创建一个挂起的线程；

0 创建后立即激活。

书上有这个函数应用的十分清晰的例子，可以自己阅读。

一般并不推荐使用 CreateTheard函数，而推荐使用RTL 库里的

System单元中定义的 BeginTheard函数，因为这除了能创建一个线程

和一个入口函数以外，还增加了几项保护措施，具体的请参阅书上的

第10页说明。

对应suspend（挂起）和resume（唤醒）的两个API 函数为：

Function SuspendThread(hThread:Thandle):DWORD;

Function ResumeThread（hThread:Thandle):DWORD;

其中，Thandle被要求控制线程的句柄，函数调用成功，返回挂

起的次数，调用不成功。则返回0xFFFFFFFF。

四、线程的终止和退出：

1)自动退出：

一个线程从Execute()过程中退出，即意味着线程的终止，此时

将调用Windows的ExitThread()函数来清除线程所占用的堆栈。

如果线程对象的 FreeOnTerminate 属性设为True，则线程对象

将自动删除，并释放线程所占用的资源。

这是消除线程对象最简单的办法。

2)受控退出：

利用线程对象的Terminate属性，可以由进程或者由其他线程控

制线程的退出。只需要简单的调用该线程的Terminate方法，并设直

线程对象的Terminate属性为True。

在线程中，应该不断监视Terminate的值，一旦发现为True，则

退出，例如在Execute()过程中可以这样写：

While not Terminate do

begin

........

end;

3)退出的API 函数：

关于线程退出的API 函数声明如下：code

Function TerminateThread(hThread:Thandle;dwExitCode:DWORD);

不过，这个函数会使代码立刻终止，而不管程序中有没有

try....finally

机制，可能会导致错误，不到万不得已，最好不要使用。

4) 利用挂起线程的方法（suspend）

利用挂起线程的suspend方法，后面跟个Free，也可以释放线程，

例如：

thread1.suspend; //挂起

thread2.free; //释放

书上有相应的例子。

五、 线程的优先级：

在多线程的情况下，一般要根据线程执行任务的重要性，给线程

适当的优先级，一般如果量的线程同时申请CPU 时间，优先级高的线

程优先。

在Windows下，给线程的优先级分为30级，而Delphi中Tthread

对象相对简单的把优先级分为七级。也就是在Tthread中声明了一个

枚举类型TTthreadPriority:

type

TTthreadPriority(tpidle,tpLowest,tpLower,tpNormal,

tpHight,tpHighest,tpTimecrital)

分别对应的是最低（系统空闲时有效，-15），较低（-2），低

（-1），正常（普通0），高（1），较高（2），最高（15）。

其中tpidle和tpTimecrital有些特殊，具体情况请阅读书上有

关内容。

设置优先级可使用thread对象的priority属性：

threadObject.priority:=Tthreadpriority(级别);

这里给出了一个演示多线程优先级的实例：

2-3 在数据库中使用多线程

一）使用ADO模式

由于Delphi 6.0的ADO 数据源控件内置了多线程能力，所以，在

ADO模式下，使用多线程不需要做更多的工作。用两个ADOTable控件，

分别连到两个数据库，并且分别通过DataSource控件，与数据帮定控

件联系就可以了，这样就可以实现前后台处理数据库问题。

二）使用BDE模式和Tseeion对象

如果需要使用BDE 模式，那么多线程使用数据库，就要考虑Session

的问题。在单线程时，每个数据源的建立就自动生成一个Session，

这是这个数据源私有的关于数据库信息的文件。但多线程时，必须统

一管理，所以在BDE 中专门提供了一个Tsession对象，它可以同时管理

不同的Databas数据源对象。

Databas数据源可以接受来自不同数据平台的数据库。

数据库1---databas(2)----table(Qurey)(3)---datasource

| |

| |

|--------- Tsession(1)

| |

| |

数据库2---databas(2)----table(Qurey)(3)---datasource

方法：

1）Tsession

属性：SessionName=名（自起）

Active=true （激活）

2）Database（可以有多个）

属性：SessionName=Tsession名

Dataname=名（自起，作为Table的标识）

AliasName=数据库别名

Connected=True （激活）

3）Table或Qurey

属性：SessionName=Tsession名（不要用默认值）

DatabaseName=如果前面起了名，这里就会出现Database

的名字。

Tablename=表名

Active=true （激活）

以后比如加入Datasoucre和其他一样，这样就可以构造两个前后

台处理的数据库管理系统了。

2-4 多线程的同步机制

同步机制，实际上是事件驱动机制，意思是让线程平时处于“休

眠”状态，除非发生某个事件才触发。

例如一个拷贝文件，拷贝线程完成一个程序块后，再唤醒进程条

线程做一个格的填充。

研究多线程的同步机制的必要性在于，多线程同步工作时，如果

同时调用相同的资源，就可能会出现问题，一般读出是不会有问题的，

但是，如果写入（全局变量、数据库），就会发生冲突，甚至产生死

锁和竞争问题。

一、使用Synchronize方法

这个方法用于访问VCL 主线程所管理的资源，其方法的应用是：

第一步：把访问主窗口（或主窗口控件资源）的代码放到线程的

一个方法中；

第二步：是在线程对象的Execute方法中，通过Synchronize方法

使用该方法。

实例：

procere Theater.Execute;

begin

Synchronize(update);

end;

procere Theater.update;

begin

.........

end;

这里通过 Synchronize使线程方法update同步。

二、使用VCL类的Look方法

在Delphi的IDE提供的构件中，有一些对象内部提供了线程的同

步机制，工作线程可以直接使用这些控件，比如：Tfont，Tpen，

TBitmap，TMetafile，Ticon等。另外，一个很重要的控件对象叫

TCanvas，提供了一个Lock方法用于线程的同步，当一个线程使用此

控件对象的时候，首先调用这个对象的Lock方法，然后对这个控件

进行操作，完毕后再调用Unlock方法，释放对控间的控制权。

例如：

CanversObject.look;

try

画图

finally

CanversObject.unlock;

end;

{使用这个保护机制,保证不论有没有异常，unlock都会被执行

否则很可能会发生死锁。在多线程设计的时候，应该很注意发生死

锁的问题}

三、Waitfor方法

当一个线程应该等待另一个线程结束时，可以调用Waitfor方法。

这个方法属于等待线程对象，Waitfor方法的原型如下:

Function Waitfor(Const Astring:string):string;

比如在前面最基本的线程的例子中，唤醒线程的语句中加上

thread1.resume;

thread1.waitfor;

thread2.resume;

那么所有的线程都必须等待thread1运行完毕后才能运行，其中

包括主线程，可以预想，由于thread1调用了主窗体的Edit控件，那

么，在thread1运行中间，Edie1也不会显示。

这就告诉我们，这样的代码是不能作为主线程的一部分的，如果

与主窗体连接的线程内等待另一个线程结束，而另一个线程又要等待

访问用户界面，就可能是程序陷于死锁。

这点在应用的时候要谨慎。

⑤ 多线程中要使用到控件的事件，请问怎么写

在多线程编程中，我们经常要在工作线程中去更新界面显示，而在多线程中直接调用界面控件的方法是错误的做法，Invoke 和 BeginInvoke 就是为了解决这个问题而出现的，使你在多线程中安全的更新界面显示。

正确的做法是将工作线程中涉及更新界面的代码封装为一个方法，通过 Invoke 或者 BeginInvoke
去调用，两者的区别就是一个导致工作线程等待，而另外一个则不会。

Framework框架的WinForm构建GUI程序界面时，如果要在控件的事件响应函数中改变控件的状态

，例如：某个按钮上的文本原先叫逗打开地，单击之后按钮上的文本显示逗关闭地，初学者往往会想当然地这么写：

void ButtonOnClick(object sender,EventArgs e)

{

button.Text="关闭";

}

这样的写法运行程序之后，可能会触发异常，异常信息大致是逗不能从不是创建该控件的线程调用它地。注意这里是逗可能地，并不一定会触发该种异常。造
成这种异常的原因在于，控件是在主线程中创建的（比如this.Controls.Add(...);)，进入控件的事件响应函数时，是在控件所在的线

程，并不是主线程。在控件的事件响应函数中改变控件的状态，可能与主线程发生线程冲突。如果主线程正在重绘控件外观，此时在别的线程改变控件外观，就会造
成画面混乱。不过这样的情况并不总会发生，如果主线程此时在重绘别的控件，就可能逃过一劫，这样的写法可以正常通过，没有触发异常。

正确的写法是在控件响应函数中调用控件的Invoke方法（其实如果大家以前用过C++

Builder的话，也会找到类似Invoke那样的激活到主线程的函数）。Invoke方法会顺着控件树向上搜索，直到找到创建控件的那个线程（通常是主线程），然后进入那个线程改变控件的外观，确保不发生线程冲突。

而所谓的逗一面响应操作，一面添加节点地永远只能是相对的，使 UI 线程的负担不至于太大而已，因为界面的正确更新始终要通过 UI
线程去做，我们要做的事情是在工作线程中包揽大部分的运算，而将对纯粹的界面更新放到 UI 线程中去做，这样也就达到了减轻 UI
线程负担的目的了。

举个简单例子说明下使用方法,比如你在启动一个线程,在线程的方法中想更新窗体中的一个TextBox..

using System.Threading;

//启动一个线程
Thread thread=new Thread(new
ThreadStart(DoWork));
thread.Start();

//线程方法
private void DoWork()
{
this.TextBox1.Text="我是一个文本框";
}

如果你像上面操作,在VS2005或2008里是会有异常的...

正确的做法是用Invoke\BeginInvoke

using System.Threading;
namespace test
{
public partial class Form1 : Form
{
public delegate void MyInvoke(string str1,string str2);
public Form1()
{
InitializeComponent();

}
public void DoWork()
{
MyInvoke mi = new MyInvoke(UpdateForm);
this.BeginInvoke(mi, new Object[] {"我是文本框","haha"});
}
public void UpdateForm(string param1,string parm2)
{
this.textBox1.Text = param1+parm2;
}
private void button1_Click(object sender, EventArgs e)
{
Thread thread = new Thread(new ThreadStart(DoWork));
thread.Start();
}
}
}

⑥ 多线程间怎么共用主线程的cmscomm控件

1:添加MSComm控件2:为对话框添加MSComm控件成员变量右击MSComm控件，然后选择Add Variable...3:为对话框添加OnComm事件右击MSComm控件，然后选择Add Event Handle..4:打开/关闭串口.
void Ctbox_debug_viewDlg::OnBnClickedBtOpen()
{
// TODO: Add your control notification handler code here
if(m_mscomm.get_PortOpen())
{
m_mscomm.put_PortOpen(FALSE);
GetDlgItem(IDC_BT_OPEN)->SetWindowText(_T("打开"));
ShowInfo(_T("关闭串口成功!"));
m_OpenStatus =false;
return;
}
UpdateData(TRUE);
m_OpenStatus =true;
//当前端口号
m_mscomm.put_CommPort(m_Port+1);//端口号
m_mscomm.put_InBufferSize(1024);//接收缓冲区
m_mscomm.put_OutBufferSize(1024);//发送缓冲区
m_mscomm.put_InputLen(0);//设置当前接收区数据长度为0，表示全部读取
m_mscomm.put_InputMode(1);//以二进制方式读写数据
m_mscomm.put_RThreshold(1);//接收缓冲区有1个及1个以上字符时，将引发接收数据的OnComm事件
//波特率
DWORD baudrate;
switch(m_CombolBaudrate.GetCurSel())
{
case 0:
baudrate =115200;
break;
case 1:
baudrate =9600;
break;
default:
ASSERT(FALSE);
break;
}
CString setting;
setting.Format(_T("%d,n,8,1"),baudrate);
m_mscomm.put_Settings(setting/*_T("115200,n,8,1")*/);//波特率，无校验，8个数据位，1个停止1位
m_mscomm.put_PortOpen(TRUE);//打开串口
GetDlgItem(IDC_BT_OPEN)->SetWindowText(_T("关闭"));
ShowInfo(_T("打开串口成功!"));
}
5:接收串口数据
void Ctbox_debug_viewDlg::OnCommMscomm1()
{
// TODO: Add your message handler code here
short curEvent =m_mscomm.get_CommEvent();
switch(curEvent)
{
case CMscomm1::comEvReceive:
EvReceiveHandle();
break;
}
}
void Ctbox_debug_viewDlg::EvReceiveHandle(void)
{
static unsigned int cnt=0;
VARIANT variant_inp;
COleSafeArray safearray_inp;
long len,k;
/*unsigned intdata[1024]={0};*/
BYTE rxdata[1024];//设置BYTE数组
CString strtemp;
cnt++;
variant_inp= m_mscomm.get_Input();//读取缓冲区
safearray_inp= variant_inp;//变量转换
len= safearray_inp.GetOneDimSize();//得到有效的数据长度
for (k=0;k<len;k++)
{
safearray_inp.GetElement(&k,rxdata+k);
}
/*char c_char; */
for (k=0;k<len;k++)
{
strtemp.Format(_T("%c"),*(rxdata+k));
m_RecveString +=strtemp;
if(*(rxdata+k) =='\n')
{
ShowInfoByFilter(m_RecveString);
m_RecveString ="";
}
}
}
6:发送串口数据
void Ctbox_debug_viewDlg::OnBnClickedBtSend()
{
// TODO: Add your control notification handler code here
if(m_OpenStatus ==false)
{
AfxMessageBox(_T("请先打开串口"));
return;
}
UpdateData(TRUE);
if(m_SendString.IsEmpty())
return;
if(m_AutoAddLF)
{
m_SendString +="\r\n";
}
m_mscomm.put_Output(COleVariant(m_SendString));
ShowInfo(m_SendString);
}

⑦ c#如何跨线程调用窗体控件

要从其他跨线程存取调用控件，可采用以下两种方法之一：

方法1）不进行线程安全的检查

方法2）通过委托的方式

代码如下所示

publicpartialclassForm1:Form
{
publicForm1()
{
InitializeComponent();
//方法1：不进行跨线程安全检查
//System.Windows.Forms.Control.=false;
}

privatevoidbutton1_Click(objectsender,EventArgse)
{
Threadth1=newThread(newThreadStart(CalNum));
th1.Start();
}

privatevoidCalNum()
{
//button1.Enabled=false;

intresult=0;
for(inti=1;i<100000000;i++)
{
result+=i;
}

SetCalResult(result);

//button1.Enabled=true;
}

//方法2：检查是否跨线程，然后将方法加入委托，调用委托
(intresult);
privatevoidSetCalResult(intresult)
{
if(label2.InvokeRequired==true)
{
SetTextHandlerset=newSetTextHandler(SetCalResult);//委托的方法参数应和SetCalResult一致
label2.Invoke(set,newobject[]{result});//此方法第二参数用于传入方法,代替形参result
}
else
{
label2.Text=result.ToString();
}
}
}

⑧ C#中多线程里面如何调用控件

定义委托，然后用invoke
private void ucMidPartsid_Load(object sender, EventArgs e)
{

if (is_Load == true)
{
thread = new Thread(new ThreadStart(this.LoadData));
thread.Start();
}
//if (datafinish != null)
//{
// datafinish(this, e);
//}
}
private void LoadData()
{
QueryDataCallBack deleg;
deleg = new QueryDataCallBack(this.DataBinding);
this.Invoke(deleg,null);

}
private void DataBinding()
{
partstableAdapter = new GreatWall.SCM.Parts.DataAccess.DAParts.PartsTableAdapter();
partstableAdapter.Fill(dsParts.GB_PARTS);
cobMidPartsid.DataSource = dsParts.GB_PARTS;
cobMidPartsid.DisplayMember = "B_PARTSID";
cobMidPartsid.ValueMember = "B_ID";
EventArgs e = new EventArgs();
if (datafinish != null)
{
finish = true;
datafinish(this, e);
}

}

⑨ C#多线程如何调用主线程创建的控件

1.新开的线程是无法直接访问UI控件的，如果需要访问，可以通过控件的Invoke方法，或者用

System.Threading.SynchronizationContext.Current.Post方法

2.一定不要在控件的内部事件处理方法里面使用Sleep等线程暂停方法！

像我这样写就不会阻塞了：

private void button1_Click(object sender, EventArgs e)
{
System.Threading.Thread thread = new System.Threading.Thread(() =>
{
while (true)
{
this.Invoke(new Action(() =>
{
label1.Text = (count++).ToString();
}));
System.Threading.Thread.Sleep(100);
}
});
thread.IsBackground = true;
thread.Start();
}

你把setmess这个线程方法Invoke到了UI的主线程上了，而这个线程里面有暂停方法，所以呢主线程也会暂停卡住。
而我的方法只是把“label1.Text = (count++).ToString();”Invoke到主线程，而那个新的线程并没有Invoke到主线程，所以在那个线程里面使用暂停就没事了！

假如有一个操作比较费时，或者需要等待之类的，就像我这样开始一个新的线程，所以的等待操作，费时的操作都在在这个线程里面做，当这些线程需要访问UI控件的时候，就用this.Invoke()这个方法！