winform 多线程如何刷新控件，在线等.....

Question

在一个form中有listbox控件，在form启动后，自动执行多线程，在线程中不时刷新listbox控件。在常见的例子中，多线程是一个form类中函数，所以在多线程中可以看见listbox，之后进行委托即可，但是我现在要执行的多线程是另一个类中的函数（添加了新类mythread），在这个类中listbox不可见，无法委托，要是form n =new form(); xxx+ = new mydelegate(n.setlistbox);，不是刷新原来的listbox控件，是新建一个form （n)，刷新的是他的控件，如何解决，谢谢！！！！！

Answer 1

直接调用 form1.setlistbox  不可以么 不用new 一个form 用原来的form对象
另外 还要做些别的VS2005 多线程问题--窗体中的线程安全调用 part1(2008-08-26 11:19:02)标签：杂谈   分类：ASP.NET/C# 
访问 Windows 窗体控件本质上不是线程安全的。如果有两个或多个线程操作某一控件的状态，则可能会迫使该控件进入一种不一致的状态。还可能出现其他与线程相关的 bug，包括争用情况和死锁。确保以线程安全方式访问控件非常重要。.NET Framework 有助于在以非线程安全方式访问控件时检测到这一问题。在调试器中运行应用程序时，如果创建某控件的线程之外的其他线程试图调用该控件，则调试器会引发一个 InvalidOperationException，并提示消息：“从不是创建控件 control name 的线程访问它。”有三种方法可以从线程访问Win窗体的控件：非线程安全方式；线程安全调用；使用BackgroundWorker进行的线程安全调用。其中，只有线程的安全调用可以宏观并行处理。（另外两种方式都是在线程运行时接受命令，但在线程执行完以后才执行）。一：对Windows窗体控件的非线程安全调用该方式是从辅助线程直接调用。调用应用程序时，调试器会引发一个InvalidOperationException，警告对控件的调用不是线程安全的。可以通过将 CheckForIllegalCrossThreadCalls 属性的值设置为 false 来禁用此异常。这会使控件以与在 Visual Studio 2003 下相同的方式运行。具体做法如下： public Form1()
        ...{
             InitializeComponent();
             Control.CheckForIllegalCrossThreadCalls = false;//这一行是关键 用于对线程的不安全调用
         }
 二：对Windows窗体控件的线程安全调用对窗体控件的线程安全调用需要用委托的方式。主要思路：1、查询控件的 InvokeRequired 属性。2、如果 InvokeRequired 返回 true，则使用实际调用控件的委托来调用 Invoke。3、如果 InvokeRequired 返回 false，则直接调用控件。例子：在TextBox控件中输出相应的信息，SetText为textbox的内容设置方法，SetTextDelegate的委托类型封装 SetText方法。TextBox控件的InvokeRequired返回true是，SetText方法创建SetTextDelegate的一个实例，并调用窗体的Invoke方法。是的SetText方法被创建TextBox控件的线程调用。    // 该事件句柄创建一个对窗体控件线程安全调用的线程private void setTextSafeBtn_Click( object sender,   EventArgs e)
...{
    this.demoThread =
        new Thread(new ThreadStart(this.ThreadProcSafe));    this.demoThread.Start();
}// 该方法在Worker线程中执行并且发出一个线程安全的调用private void ThreadProcSafe()
...{
    this.SetText("This text was set safely.");
}//如果被调用的线程和创建的TextBox控件不同，该方法就创建一个SetTextCallback，// 并且用Invoke方法异步调用自己。
// 如果相同，则直接调用方法设置Text的属性。private void SetText(string text)
...{
    // 获取的InvokeRequired将调用的线程ID和创建的线程ID向比较。
    //如果两个线程ID不同，则返回true       if (this.textBox1.InvokeRequired)
     ...{   
         SetTextCallback d = new SetTextCallback(SetText);
        this.Invoke(d, new object[] ...{ text });
     }
    else
    ...{
        this.textBox1.Text = text;
     }
}

Answer 2

利用 for each 函数循环判断所有控件，某类控件需要指定某类的控件类型！c# winform 循环遍历界面上的所有控件，foreach，Controls，AllowDrop
遍历 控件 foreach C#代码 
foreach (System.Windows.Forms.Control control in this.groupBox2.Controls)//遍历groupBox2上的所有控件   
   {   
    if (control is System.Windows.Forms.PictureBox)   
    {   
     System.Windows.Forms.PictureBox pb = (System.Windows.Forms.PictureBox)control;   
     pb.AllowDrop = true;   
    }   
   }  C#代码
foreach (System.Windows.Forms.Control control in this.Controls)//遍历Form上的所有控件   
   {   
    if (control is System.Windows.Forms.PictureBox)   
    {   
     System.Windows.Forms.PictureBox pb = (System.Windows.Forms.PictureBox)control;   
     pb.AllowDrop = true;   
    }   
   }  

Answer 3

写得可够乱的,把那个Listbox封装成一个静态属性试试
public static ListBox YourListBox {get { return this.listbox1; }}
多线程中调用该属性

Answer 4

to: jingshuaizh
-------------------------------- 
form1.setlistbox  不是静态函数，无法调用！！！！！

Answer 5

kkun_3yue3 
－－－－－－－－－－－－－－－－－－－－－－－－－
我希望用委托实现？静态的估计没事，但是看着不舒服！！！

Answer 6

那你在mythread类里面写一个静态的委托
在form里面指向setlistbox方法就可以了

Answer 7

后台线程问主线程要一个 Synchronization， 在需要更新主界面的时候， 后台线程使用事件通知主线程，同时把Synchronization 作为事件参数封装进去。主线程响应了后台线程的事件，就可以通过参数 Synchronization, 线程安全地更新主界面

Answer 8

我想更新的是textBox ， MainForm.textBox1.Text = showData; 编译的时候会出现 “非静态的字段、方法或属性“MainForm.textBox1”要求对象引用“ 的错误提示~~

Answer 9

你的form对象要传递到后台线程里才行。MainForm只是类，不是对象。

Answer 10

msdn里面有个关于线程安全的例子。不知道是不是楼主想要的。
using System;
using System.ComponentModel;
using System.Threading;
using System.Windows.Forms;namespace CrossThreadDemo
{
public class Form1 : Form
{
// This delegate enables asynchronous calls for setting
// the text property on a TextBox control.
delegate void SetTextCallback(string text); // This thread is used to demonstrate both thread-safe and
// unsafe ways to call a Windows Forms control.
private Thread demoThread = null; // This BackgroundWorker is used to demonstrate the 
// preferred way of performing asynchronous operations.
private BackgroundWorker backgroundWorker1; private TextBox textBox1;
private Button setTextUnsafeBtn;
private Button setTextSafeBtn;
private Button setTextBackgroundWorkerBtn; private System.ComponentModel.IContainer components = null; public Form1()
{
InitializeComponent();
} protected override void Dispose(bool disposing)
{
if (disposing && (components != null))
{
components.Dispose();
}
base.Dispose(disposing);
} // This event handler creates a thread that calls a 
// Windows Forms control in an unsafe way.
private void setTextUnsafeBtn_Click(
object sender, 
EventArgs e)
{
this.demoThread = 
new Thread(new ThreadStart(this.ThreadProcUnsafe)); this.demoThread.Start();
} // This method is executed on the worker thread and makes
// an unsafe call on the TextBox control.
private void ThreadProcUnsafe()
{
this.textBox1.Text = "This text was set unsafely.";
} // This event handler creates a thread that calls a 
// Windows Forms control in a thread-safe way.
private void setTextSafeBtn_Click(
object sender, 
EventArgs e)
{
this.demoThread = 
new Thread(new ThreadStart(this.ThreadProcSafe)); this.demoThread.Start();
} // This method is executed on the worker thread and makes
// a thread-safe call on the TextBox control.
private void ThreadProcSafe()
{
this.SetText("This text was set safely.");
} // This method demonstrates a pattern for making thread-safe
// calls on a Windows Forms control. 
//
// If the calling thread is different from the thread that
// created the TextBox control, this method creates a
// SetTextCallback and calls itself asynchronously using the
// Invoke method.
//
// If the calling thread is the same as the thread that created
// the TextBox control, the Text property is set directly.  private void SetText(string text)
{
// InvokeRequired required compares the thread ID of the
// calling thread to the thread ID of the creating thread.
// If these threads are different, it returns true.
if (this.textBox1.InvokeRequired)
{
SetTextCallback d = new SetTextCallback(SetText);
this.Invoke(d, new object[] { text });
}
else
{
this.textBox1.Text = text;
}
} // This event handler starts the form's 
// BackgroundWorker by calling RunWorkerAsync.
//
// The Text property of the TextBox control is set
// when the BackgroundWorker raises the RunWorkerCompleted
// event.
private void setTextBackgroundWorkerBtn_Click(
object sender, 
EventArgs e)
{
this.backgroundWorker1.RunWorkerAsync();
}

// This event handler sets the Text property of the TextBox
// control. It is called on the thread that created the 
// TextBox control, so the call is thread-safe.
//
// BackgroundWorker is the preferred way to perform asynchronous
// operations. private void backgroundWorker1_RunWorkerCompleted(
object sender, 
RunWorkerCompletedEventArgs e)
{
this.textBox1.Text = 
"This text was set safely by BackgroundWorker.";
} #region Windows Form Designer generated code private void InitializeComponent()
{
this.textBox1 = new System.Windows.Forms.TextBox();
this.setTextUnsafeBtn = new System.Windows.Forms.Button();
this.setTextSafeBtn = new System.Windows.Forms.Button();
this.setTextBackgroundWorkerBtn = new System.Windows.Forms.Button();
this.backgroundWorker1 = new System.ComponentModel.BackgroundWorker();
this.SuspendLayout();
// 
// textBox1
// 
this.textBox1.Location = new System.Drawing.Point(12, 12);
this.textBox1.Name = "textBox1";
this.textBox1.Size = new System.Drawing.Size(240, 20);
this.textBox1.TabIndex = 0;
// 
// setTextUnsafeBtn
// 
this.setTextUnsafeBtn.Location = new System.Drawing.Point(15, 55);
this.setTextUnsafeBtn.Name = "setTextUnsafeBtn";
this.setTextUnsafeBtn.TabIndex = 1;
this.setTextUnsafeBtn.Text = "Unsafe Call";
this.setTextUnsafeBtn.Click += new System.EventHandler(this.setTextUnsafeBtn_Click);
// 
// setTextSafeBtn
// 
this.setTextSafeBtn.Location = new System.Drawing.Point(96, 55);
this.setTextSafeBtn.Name = "setTextSafeBtn";
this.setTextSafeBtn.TabIndex = 2;
this.setTextSafeBtn.Text = "Safe Call";
this.setTextSafeBtn.Click += new System.EventHandler(this.setTextSafeBtn_Click);
// 
// setTextBackgroundWorkerBtn
// 
this.setTextBackgroundWorkerBtn.Location = new System.Drawing.Point(177, 55);
this.setTextBackgroundWorkerBtn.Name = "setTextBackgroundWorkerBtn";
this.setTextBackgroundWorkerBtn.TabIndex = 3;
this.setTextBackgroundWorkerBtn.Text = "Safe BW Call";
this.setTextBackgroundWorkerBtn.Click += new System.EventHandler(this.setTextBackgroundWorkerBtn_Click);
// 
// backgroundWorker1
// 
this.backgroundWorker1.RunWorkerCompleted += new System.ComponentModel.RunWorkerCompletedEventHandler(this.backgroundWorker1_RunWorkerCompleted);
// 
// Form1
// 
this.ClientSize = new System.Drawing.Size(268, 96);
this.Controls.Add(this.setTextBackgroundWorkerBtn);
this.Controls.Add(this.setTextSafeBtn);
this.Controls.Add(this.setTextUnsafeBtn);
this.Controls.Add(this.textBox1);
this.Name = "Form1";
this.Text = "Form1";
this.ResumeLayout(false);
this.PerformLayout(); } #endregion
[STAThread]
static void Main()
{
Application.EnableVisualStyles();
Application.Run(new Form1());
} }
}

Answer 11

VS2010中Control.CheckForIllegalCrossThreadCalls = false就是这样的；

Answer 12

看到这个帖子很难过。
第一是我也遇到了这个问题。
第二是没看到解决办法。
楼上众多高手都讲述了如何在Form类里启动一个线程并且安全的访问Form上的一个控件
this.textBox1
可惜的是，这个所谓的线程也是在这个类里的，它认识textBox1。要是在另一个类里怎么办？
根本就没有this.textBox1啊

Answer 13

使用BackgroundWorder控件后台运行，并在它的ProgressChanged 事件和RunWorkerCompleted 事件里与其它控件互动。这才是正道。
多线程什么的，根本无法调试

Answer 14

在线程执行中，是无法直接访问控件的，要用Invoke