从另一个线程更新Label的最简单方法是什么？
我在Form上有一个thread1，从那里我开始另一个线程（thread2）。虽然thread2正在处理某些文件，但我想更新Label上的Form，其当前状态为thread2。
我该怎么做？
答案 0 :(得分：1006)
最简单方式是传递给Label.Invoke的匿名方法：
// Running on the worker thread
string newText = "abc";
form.Label.Invoke((MethodInvoker)delegate {
// Running on the UI thread
form.Label.Text = newText;
});
// Back on the worker thread
请注意Invoke阻止执行直到完成 - 这是同步代码。这个问题并不是关于异步代码的问题，但是当你想要了解异步代码时，有许多关于编写异步代码的content on Stack Overflow。
答案 1 :(得分：738)
对于.NET 2.0，这里有一些我编写的代码，它完全符合您的要求，适用于Control上的任何属性：
private delegate void SetControlPropertyThreadSafeDelegate(
Control control,
string propertyName,
object propertyValue);
public static void SetControlPropertyThreadSafe(
Control control,
string propertyName,
object propertyValue)
{
if (control.InvokeRequired)
{
control.Invoke(new SetControlPropertyThreadSafeDelegate
(SetControlPropertyThreadSafe),
new object[] { control, propertyName, propertyValue });
}
else
{
control.GetType().InvokeMember(
propertyName,
BindingFlags.SetProperty,
null,
control,
new object[] { propertyValue });
}
}
这样称呼：
// thread-safe equivalent of
// myLabel.Text = status;
SetControlPropertyThreadSafe(myLabel, "Text", status);
如果您使用的是.NET 3.0或更高版本，则可以将上述方法重写为Control类的扩展方法，这样可以简化对以下内容的调用：
myLabel.SetPropertyThreadSafe("Text", status);
更新05/10/2010：
对于.NET 3.0，您应该使用以下代码：
private delegate void SetPropertyThreadSafeDelegate<TResult>(
Control @this,
Expression<Func<TResult>> property,
TResult value);
public static void SetPropertyThreadSafe<TResult>(
this Control @this,
Expression<Func<TResult>> property,
TResult value)
{
var propertyInfo = (property.Body as MemberExpression).Member
as PropertyInfo;
if (propertyInfo == null ||
!@this.GetType().IsSubclassOf(propertyInfo.ReflectedType) ||
@this.GetType().GetProperty(
propertyInfo.Name,
propertyInfo.PropertyType) == null)
{
throw new ArgumentException("The lambda expression 'property' must reference a valid property on this Control.");
}
if (@this.InvokeRequired)
{
@this.Invoke(new SetPropertyThreadSafeDelegate<TResult>
(SetPropertyThreadSafe),
new object[] { @this, property, value });
}
else
{
@this.GetType().InvokeMember(
propertyInfo.Name,
BindingFlags.SetProperty,
null,
@this,
new object[] { value });
}
}
使用LINQ和lambda表达式来允许更清晰，更简单和更安全的语法：
myLabel.SetPropertyThreadSafe(() => myLabel.Text, status); // status has to be a string or this will fail to compile
现在不仅在编译时检查属性名称，属性的类型也是如此，因此不可能（例如）将字符串值赋给布尔属性，从而导致运行时异常。
不幸的是，这并不能阻止任何人做一些愚蠢的事情，例如传递另一个Control的属性和值，所以以下内容将很乐意编译：
myLabel.SetPropertyThreadSafe(() => aForm.ShowIcon, false);
因此，我添加了运行时检查，以确保传入的属性确实属于调用该方法的Control。不完美，但仍然比.NET 2.0版本好很多。
如果有人对如何为编译时安全性改进此代码有任何进一步的建议，请发表评论！
答案 2 :(得分：371)
自.NET 4.5 and C# 5.0以来，您应该使用Task-based Asynchronous Pattern (TAP)以及async - await个关键字in all areas（包括GUI）：
TAP是新开发的推荐异步设计模式
而不是Asynchronous Programming Model (APM)和Event-based Asynchronous Pattern (EAP)（后者包括BackgroundWorker Class）。
然后，推荐的新开发解决方案是：
事件处理程序的异步实现（是的，就是全部）：
private async void Button_Clicked(object sender, EventArgs e)
{
var progress = new Progress<string>(s => label.Text = s);
await Task.Factory.StartNew(() => SecondThreadConcern.LongWork(progress),
TaskCreationOptions.LongRunning);
label.Text = "completed";
}
实现通知UI线程的第二个线程：
class SecondThreadConcern
{
public static void LongWork(IProgress<string> progress)
{
// Perform a long running work...
for (var i = 0; i < 10; i++)
{
Task.Delay(500).Wait();
progress.Report(i.ToString());
}
}
}
请注意以下事项：
有关更详细的示例，请参阅：The Future of C#: Good things come to those who 'await' Joseph Albahari。{/ p>
另见UI Threading Model概念。
下面的代码段是一个示例，说明如何处理异常并切换按钮的Enabled属性，以防止在后台执行期间多次点击。
private async void Button_Click(object sender, EventArgs e)
{
button.Enabled = false;
try
{
var progress = new Progress<string>(s => button.Text = s);
await Task.Run(() => SecondThreadConcern.FailingWork(progress));
button.Text = "Completed";
}
catch(Exception exception)
{
button.Text = "Failed: " + exception.Message;
}
button.Enabled = true;
}
class SecondThreadConcern
{
public static void FailingWork(IProgress<string> progress)
{
progress.Report("I will fail in...");
Task.Delay(500).Wait();
for (var i = 0; i < 3; i++)
{
progress.Report((3 - i).ToString());
Task.Delay(500).Wait();
}
throw new Exception("Oops...");
}
}
答案 3 :(得分：219)
.NET 4的Marc Gravell's simplest solution的变体：
control.Invoke((MethodInvoker) (() => control.Text = "new text"));
或者改为使用Action委托：
control.Invoke(new Action(() => control.Text = "new text"));
答案 4 :(得分：131)
针对.NET 3.5 +的Fire and forget扩展方法
using System;
using System.Windows.Forms;
public static class ControlExtensions
{
/// <summary>
/// Executes the Action asynchronously on the UI thread, does not block execution on the calling thread.
/// </summary>
/// <param name="control"></param>
/// <param name="code"></param>
public static void UIThread(this Control @this, Action code)
{
if (@this.InvokeRequired)
{
@this.BeginInvoke(code);
}
else
{
code.Invoke();
}
}
}
可以使用以下代码行调用：
this.UIThread(() => this.myLabel.Text = "Text Goes Here");
答案 5 :(得分：64)
这是你应该这样做的经典方式：
using System;
using System.Windows.Forms;
using System.Threading;
namespace Test
{
public partial class UIThread : Form
{
Worker worker;
Thread workerThread;
public UIThread()
{
InitializeComponent();
worker = new Worker();
worker.ProgressChanged += new EventHandler<ProgressChangedArgs>(OnWorkerProgressChanged);
workerThread = new Thread(new ThreadStart(worker.StartWork));
workerThread.Start();
}
private void OnWorkerProgressChanged(object sender, ProgressChangedArgs e)
{
// Cross thread - so you don't get the cross-threading exception
if (this.InvokeRequired)
{
this.BeginInvoke((MethodInvoker)delegate
{
OnWorkerProgressChanged(sender, e);
});
return;
}
// Change control
this.label1.Text = e.Progress;
}
}
public class Worker
{
public event EventHandler<ProgressChangedArgs> ProgressChanged;
protected void OnProgressChanged(ProgressChangedArgs e)
{
if(ProgressChanged!=null)
{
ProgressChanged(this,e);
}
}
public void StartWork()
{
Thread.Sleep(100);
OnProgressChanged(new ProgressChangedArgs("Progress Changed"));
Thread.Sleep(100);
}
}
public class ProgressChangedArgs : EventArgs
{
public string Progress {get;private set;}
public ProgressChangedArgs(string progress)
{
Progress = progress;
}
}
}
您的工作线程有一个事件。您的UI线程从另一个线程开始执行工作并挂接该工作事件，以便您可以显示工作线程的状态。
然后在UI中，您需要跨线程来更改实际控件......如标签或进度条。
答案 6 :(得分：59)
简单的解决方案是使用Control.Invoke。
void DoSomething()
{
if (InvokeRequired) {
Invoke(new MethodInvoker(updateGUI));
} else {
// Do Something
updateGUI();
}
}
void updateGUI() {
// update gui here
}
答案 7 :(得分：45)
线程代码经常出错并且总是难以测试。您无需编写线程代码来从后台任务更新用户界面。只需使用BackgroundWorker类来运行任务及其ReportProgress方法即可更新用户界面。通常，您只报告完成百分比，但还有另一个包含状态对象的重载。这是一个只报告字符串对象的示例：
private void button1_Click(object sender, EventArgs e)
{
backgroundWorker1.WorkerReportsProgress = true;
backgroundWorker1.RunWorkerAsync();
}
private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
{
Thread.Sleep(5000);
backgroundWorker1.ReportProgress(0, "A");
Thread.Sleep(5000);
backgroundWorker1.ReportProgress(0, "B");
Thread.Sleep(5000);
backgroundWorker1.ReportProgress(0, "C");
}
private void backgroundWorker1_ProgressChanged(
object sender,
ProgressChangedEventArgs e)
{
label1.Text = e.UserState.ToString();
}
如果您总是想要更新相同的字段，那就没问题。如果您要进行更复杂的更新，可以定义一个类来表示UI状态并将其传递给ReportProgress方法。
最后一件事，请务必设置WorkerReportsProgress标记，否则ReportProgress方法将被完全忽略。
答案 8 :(得分：39)
绝大多数答案都使用Control.Invoke race condition waiting to happen。例如，考虑接受的答案：
string newText = "abc"; // running on worker thread
this.Invoke((MethodInvoker)delegate {
someLabel.Text = newText; // runs on UI thread
});
如果用户在调用this.Invoke之前关闭了表单（请记住，this是Form对象），则可能会触发ObjectDisposedException。
解决方案是使用SynchronizationContext，特别是SynchronizationContext.Current作为hamilton.danielb建议（其他答案依赖于完全不必要的特定SynchronizationContext实施）。我会略微修改他的代码以使用SynchronizationContext.Post而不是SynchronizationContext.Send（因为通常不需要工作线程等待）：
public partial class MyForm : Form
{
private readonly SynchronizationContext _context;
public MyForm()
{
_context = SynchronizationContext.Current
...
}
private MethodOnOtherThread()
{
...
_context.Post(status => someLabel.Text = newText,null);
}
}
请注意，在.NET 4.0及更高版本中，您应该使用异步操作的任务。有关基于任务的等效方法，请参阅n-san's答案（使用TaskScheduler.FromCurrentSynchronizationContext）。
最后，在.NET 4.5及更高版本上，您还可以使用Progress<T>（基本上在创建时捕获SynchronizationContext.Current），如Ryszard Dżegan's所示，适用于长时间运行需要的情况在仍然工作的情况下运行UI代码。
答案 9 :(得分：34)
您必须确保更新发生在正确的线程上; UI线程。
为了做到这一点，你必须调用事件处理程序而不是直接调用它。
你可以通过举办这样的活动来做到这一点：
（代码在这里输入，所以我没有检查正确的语法等，但它应该让你去。）
if( MyEvent != null )
{
Delegate[] eventHandlers = MyEvent.GetInvocationList();
foreach( Delegate d in eventHandlers )
{
// Check whether the target of the delegate implements
// ISynchronizeInvoke (Winforms controls do), and see
// if a context-switch is required.
ISynchronizeInvoke target = d.Target as ISynchronizeInvoke;
if( target != null && target.InvokeRequired )
{
target.Invoke (d, ... );
}
else
{
d.DynamicInvoke ( ... );
}
}
}
请注意，上面的代码不适用于WPF项目，因为WPF控件不实现ISynchronizeInvoke接口。
为了确保上面的代码适用于Windows窗体和WPF以及所有其他平台，您可以查看AsyncOperation，AsyncOperationManager和SynchronizationContext类。
为了以这种方式容易地引发事件，我创建了一个扩展方法，它允许我通过调用简化引发事件：
MyEvent.Raise(this, EventArgs.Empty);
当然，您也可以使用BackGroundWorker类，它将为您抽象出这个问题。
答案 10 :(得分：28)
您需要在GUI线程上调用该方法。您可以通过调用Control.Invoke来实现。
例如：
delegate void UpdateLabelDelegate (string message);
void UpdateLabel (string message)
{
if (InvokeRequired)
{
Invoke (new UpdateLabelDelegate (UpdateLabel), message);
return;
}
MyLabelControl.Text = message;
}
答案 11 :(得分：26)
由于场景的微不足道，我实际上会对状态进行UI线程轮询。我想你会发现它很优雅。
public class MyForm : Form
{
private volatile string m_Text = "";
private System.Timers.Timer m_Timer;
private MyForm()
{
m_Timer = new System.Timers.Timer();
m_Timer.SynchronizingObject = this;
m_Timer.Interval = 1000;
m_Timer.Elapsed += (s, a) => { MyProgressLabel.Text = m_Text; };
m_Timer.Start();
var thread = new Thread(WorkerThread);
thread.Start();
}
private void WorkerThread()
{
while (...)
{
// Periodically publish progress information.
m_Text = "Still working...";
}
}
}
该方法避免了使用ISynchronizeInvoke.Invoke和ISynchronizeInvoke.BeginInvoke方法时所需的编组操作。使用编组技术没有任何问题，但需要注意几点需要注意。
BeginInvoke，否则可能会超出消息泵。Invoke是一个阻塞调用。它将暂时停止在该线程中完成的工作。我在这个答案中提出的策略颠倒了线程的通信角色。 UI线程轮询它而不是工作线程推送数据。这是许多场景中使用的常见模式。由于您要做的只是显示工作线程的进度信息，我认为您会发现此解决方案是编组解决方案的绝佳替代方案。它具有以下优点。
Control.Invoke或Control.BeginInvoke方法相反，UI和工作线程保持松散耦合。答案 12 :(得分：26)
以前答案中的调用内容都不是必需的。
您需要查看WindowsFormsSynchronizationContext：
// In the main thread
WindowsFormsSynchronizationContext mUiContext = new WindowsFormsSynchronizationContext();
...
// In some non-UI Thread
// Causes an update in the GUI thread.
mUiContext.Post(UpdateGUI, userData);
...
void UpdateGUI(object userData)
{
// Update your GUI controls here
}
答案 13 :(得分：22)
这个类似于上面使用.NET Framework 3.0的解决方案，但它解决了编译时安全支持的问题。
public static class ControlExtension
{
delegate void SetPropertyValueHandler<TResult>(Control souce, Expression<Func<Control, TResult>> selector, TResult value);
public static void SetPropertyValue<TResult>(this Control source, Expression<Func<Control, TResult>> selector, TResult value)
{
if (source.InvokeRequired)
{
var del = new SetPropertyValueHandler<TResult>(SetPropertyValue);
source.Invoke(del, new object[]{ source, selector, value});
}
else
{
var propInfo = ((MemberExpression)selector.Body).Member as PropertyInfo;
propInfo.SetValue(source, value, null);
}
}
}
使用：
this.lblTimeDisplay.SetPropertyValue(a => a.Text, "some string");
this.lblTimeDisplay.SetPropertyValue(a => a.Visible, false);
如果用户传递了错误的数据类型，编译器将失败。
this.lblTimeDisplay.SetPropertyValue(a => a.Visible, "sometext");
答案 14 :(得分：22)
Salvete！搜索了这个问题之后，我发现 FrankG 和 Oregon Ghost 的答案对我来说是最简单的。现在，我在Visual Basic中编码并通过转换器运行此代码段;所以我不确定结果如何。
我有一个名为form_Diagnostics,的对话框，其中有一个名为updateDiagWindow,的富文本框，我将其用作一种日志记录显示。我需要能够从所有线程更新其文本。额外的行允许窗口自动滚动到最新的行。
所以，我现在可以用你认为无需任何线程的方式在整个程序的任何地方用一行更新显示：
form_Diagnostics.updateDiagWindow(whatmessage);
主要代码（将其放在表单的类代码中）：
#region "---------Update Diag Window Text------------------------------------"
// This sub allows the diag window to be updated by all threads
public void updateDiagWindow(string whatmessage)
{
var _with1 = diagwindow;
if (_with1.InvokeRequired) {
_with1.Invoke(new UpdateDiagDelegate(UpdateDiag), whatmessage);
} else {
UpdateDiag(whatmessage);
}
}
// This next line makes the private UpdateDiagWindow available to all threads
private delegate void UpdateDiagDelegate(string whatmessage);
private void UpdateDiag(string whatmessage)
{
var _with2 = diagwindow;
_with2.appendtext(whatmessage);
_with2.SelectionStart = _with2.Text.Length;
_with2.ScrollToCaret();
}
#endregion
答案 15 :(得分：20)
出于多种目的，它就像这样简单：
public delegate void serviceGUIDelegate();
private void updateGUI()
{
this.Invoke(new serviceGUIDelegate(serviceGUI));
}
“serviceGUI（）”是表单（this）中的GUI级别方法，可以根据需要更改任意数量的控件。从另一个线程调用“updateGUI（）”。可以添加参数来传递值，或者（可能更快）使用带有锁定的类范围变量，如果有可能在访问它们的线程之间发生冲突而导致不稳定。如果非GUI线程是时间关键的，请使用BeginInvoke而不是Invoke（记住Brian Gideon的警告）。
答案 16 :(得分：20)
这是Ian Kemp解决方案的C＃3.0变体：
public static void SetPropertyInGuiThread<C,V>(this C control, Expression<Func<C, V>> property, V value) where C : Control
{
var memberExpression = property.Body as MemberExpression;
if (memberExpression == null)
throw new ArgumentException("The 'property' expression must specify a property on the control.");
var propertyInfo = memberExpression.Member as PropertyInfo;
if (propertyInfo == null)
throw new ArgumentException("The 'property' expression must specify a property on the control.");
if (control.InvokeRequired)
control.Invoke(
(Action<C, Expression<Func<C, V>>, V>)SetPropertyInGuiThread,
new object[] { control, property, value }
);
else
propertyInfo.SetValue(control, value, null);
}
你这样称呼它：
myButton.SetPropertyInGuiThread(b => b.Text, "Click Me!")
否则，原版是一个非常好的解决方案。
答案 17 :(得分：19)
当我遇到同样的问题时，我向谷歌寻求帮助，但不是给我一个简单的解决方案，而是通过提供MethodInvoker和blah blah blah的例子让我更加困惑。所以我决定自己解决它。这是我的解决方案：
像这样委托：
Public delegate void LabelDelegate(string s);
void Updatelabel(string text)
{
if (label.InvokeRequired)
{
LabelDelegate LDEL = new LabelDelegate(Updatelabel);
label.Invoke(LDEL, text);
}
else
label.Text = text
}
您可以在像这样的新线程中调用此函数
Thread th = new Thread(() => Updatelabel("Hello World"));
th.start();
不要与Thread(() => .....)混淆。我在线程上工作时使用匿名函数或lambda表达式。要减少代码行，您也可以使用ThreadStart(..)方法，我不应该在这里解释。
答案 18 :(得分：19)
Label lblText; //initialized elsewhere
void AssignLabel(string text)
{
if (InvokeRequired)
{
BeginInvoke((Action<string>)AssignLabel, text);
return;
}
lblText.Text = text;
}
请注意，BeginInvoke()优先于Invoke()，因为它不太可能导致死锁（但是，仅在将标签分配给标签时，这不是问题）：
使用Invoke()时，您正在等待返回的方法。现在，可能是你在需要等待线程的调用代码中做了一些事情，如果它隐藏在你正在调用的某些函数中，这可能不会立即明显，这本身可能通过事件处理程序间接发生。所以你会等待线程，线程会等你，你就陷入僵局。
这实际上导致我们发布的一些软件挂起。通过将Invoke()替换为BeginInvoke()，可以轻松解决问题。除非您需要同步操作（如果需要返回值），否则请使用BeginInvoke()。
答案 19 :(得分：16)
只需使用以下内容：
this.Invoke((MethodInvoker)delegate
{
progressBar1.Value = e.ProgressPercentage; // runs on UI thread
});
答案 20 :(得分：15)
您可以使用已存在的代理Action：
private void UpdateMethod()
{
if (InvokeRequired)
{
Invoke(new Action(UpdateMethod));
}
}
答案 21 :(得分：14)
我的版本是插入一行的递归“咒语”：
没有参数：
void Aaaaaaa()
{
if (InvokeRequired) { Invoke(new Action(Aaaaaaa)); return; } //1 line of mantra
// Your code!
}
对于具有参数的函数：
void Bbb(int x, string text)
{
if (InvokeRequired) { Invoke(new Action<int, string>(Bbb), new[] { x, text }); return; }
// Your code!
}
这是IT 。
一些论证：通常，在一行if ()语句之后放置{}会导致代码可读性不佳。但在这种情况下，它是常规的“咒语”。如果此方法在项目中保持一致，则不会破坏代码可读性。它可以使您的代码免于乱扔垃圾（一行代码而不是五行）。
如您所见[{1}}，您只知道“从另一个线程调用此函数是安全的”。
答案 22 :(得分：13)
尝试使用此
刷新标签public static class ExtensionMethods
{
private static Action EmptyDelegate = delegate() { };
public static void Refresh(this UIElement uiElement)
{
uiElement.Dispatcher.Invoke(DispatcherPriority.Render, EmptyDelegate);
}
}
答案 23 :(得分：13)
创建一个类变量：
SynchronizationContext _context;
在创建UI的构造函数中设置它：
var _context = SynchronizationContext.Current;
如果您想更新标签：
_context.Send(status =>{
// UPDATE LABEL
}, null);
答案 24 :(得分：12)
您必须使用invoke和delegate
private delegate void MyLabelDelegate();
label1.Invoke( new MyLabelDelegate(){ label1.Text += 1; });
答案 25 :(得分：9)
在这个问题上，我对大多数其他答案都有点复杂（我是C＃的新手），所以我写的是我的：
我有一个 WPF 应用程序，并且已经定义了一个worker，如下所示：
问题：
BackgroundWorker workerAllocator;
workerAllocator.DoWork += delegate (object sender1, DoWorkEventArgs e1) {
// This is my DoWork function.
// It is given as an anonymous function, instead of a separate DoWork function
// I need to update a message to textbox (txtLog) from this thread function
// Want to write below line, to update UI
txt.Text = "my message"
// But it fails with:
// 'System.InvalidOperationException':
// "The calling thread cannot access this object because a different thread owns it"
}
解决方案：
workerAllocator.DoWork += delegate (object sender1, DoWorkEventArgs e1)
{
// The below single line works
txtLog.Dispatcher.BeginInvoke((Action)(() => txtLog.Text = "my message"));
}
我还没有找出上述内容的含义，但它确实有效。
WinForms ：
解决方案：
txtLog.Invoke((MethodInvoker)delegate
{
txtLog.Text = "my message";
});
答案 26 :(得分：8)
例如，访问当前线程以外的控件：
Speed_Threshold = 30;
textOutput.Invoke(new EventHandler(delegate
{
lblThreshold.Text = Speed_Threshold.ToString();
}));
lblThreshold是标签，Speed_Threshold是全局变量。
答案 27 :(得分：8)
当您在UI线程中时，您可以询问它的同步上下文任务调度程序。它会给你一个TaskScheduler来安排UI线程上的所有内容。
然后你可以链接你的任务，这样当结果准备就绪时，另一个任务（在UI线程上安排）会选择它并将它分配给标签。
public partial class MyForm : Form
{
private readonly TaskScheduler _uiTaskScheduler;
public MyForm()
{
InitializeComponent();
_uiTaskScheduler = TaskScheduler.FromCurrentSynchronizationContext();
}
private void buttonRunAsyncOperation_Click(object sender, EventArgs e)
{
RunAsyncOperation();
}
private void RunAsyncOperation()
{
var task = new Task<string>(LengthyComputation);
task.ContinueWith(antecedent =>
UpdateResultLabel(antecedent.Result), _uiTaskScheduler);
task.Start();
}
private string LengthyComputation()
{
Thread.Sleep(3000);
return "47";
}
private void UpdateResultLabel(string text)
{
labelResult.Text = text;
}
}
这适用于preferred way of writing concurrent code now的任务（而不是线程）。
答案 28 :(得分：8)
我刚刚阅读了答案，这似乎是一个非常热门的话题。我目前正在使用.NET 3.5 SP1和Windows Forms。
以前的答案中大量描述的众所周知的公式使用了 InvokeRequired 属性，涵盖了大多数情况，但不包括整个池。
如果尚未创建句柄，该怎么办？
InvokeRequired 属性，如前所述，here (Control.InvokeRequired Property reference to MSDN)如果调用是从非线程的线程调用，则返回true，如果调用是从GUI线程调用，则返回false，或者如果尚未创建句柄。
如果您希望另一个线程显示和更新模式表单，则可能会遇到异常。因为您希望以模态方式显示该表单，所以您可以执行以下操作：
private MyForm _gui;
public void StartToDoThings()
{
_gui = new MyForm();
Thread thread = new Thread(SomeDelegate);
thread.Start();
_gui.ShowDialog();
}
委托可以更新GUI上的标签：
private void SomeDelegate()
{
// Operations that can take a variable amount of time, even no time
//... then you update the GUI
if(_gui.InvokeRequired)
_gui.Invoke((Action)delegate { _gui.Label1.Text = "Done!"; });
else
_gui.Label1.Text = "Done!";
}
如果标签更新前的操作花费更少的时间，则可能会导致 InvalidOperationException 。 （阅读并将其解释为简化），而不是GUI线程创建表单 句柄所需的时间。这发生在 ShowDialog（）方法中。
您还应该检查句柄，如下所示：
private void SomeDelegate()
{
// Operations that can take a variable amount of time, even no time
//... then you update the GUI
if(_gui.IsHandleCreated) // <---- ADDED
if(_gui.InvokeRequired)
_gui.Invoke((Action)delegate { _gui.Label1.Text = "Done!"; });
else
_gui.Label1.Text = "Done!";
}
如果尚未创建句柄，您可以执行要执行的操作：您可以忽略GUI更新（如上面的代码所示），也可以等待（风险更大）。 这应该回答这个问题。
可选内容： 就个人而言，我想出了以下代码：
public class ThreadSafeGuiCommand
{
private const int SLEEPING_STEP = 100;
private readonly int _totalTimeout;
private int _timeout;
public ThreadSafeGuiCommand(int totalTimeout)
{
_totalTimeout = totalTimeout;
}
public void Execute(Form form, Action guiCommand)
{
_timeout = _totalTimeout;
while (!form.IsHandleCreated)
{
if (_timeout <= 0) return;
Thread.Sleep(SLEEPING_STEP);
_timeout -= SLEEPING_STEP;
}
if (form.InvokeRequired)
form.Invoke(guiCommand);
else
guiCommand();
}
}
我提供的表单由另一个具有此 ThreadSafeGuiCommand 实例的线程更新，我定义了更新GUI（在我的表单中）的方法，如下所示：
public void SetLabeTextTo(string value)
{
_threadSafeGuiCommand.Execute(this, delegate { Label1.Text = value; });
}
通过这种方式，我非常确定我会更新任何线程进行调用的GUI，可选择等待明确定义的时间（超时）。
答案 29 :(得分：7)
我认为最简单的方法：
void Update()
{
BeginInvoke((Action)delegate()
{
//do your update
});
}
答案 30 :(得分：7)
WPF应用程序中最简单的方法是：
this.Dispatcher.Invoke((Action)(() =>
{
// This refers to a form in a WPF application
val1 = textBox.Text; // Access the UI
}));
答案 31 :(得分：6)
我想添加警告，因为我注意到一些简单的解决方案省略了InvokeRequired检查。
我注意到如果你的代码在创建控件的窗口句柄之前执行 （例如在显示表单之前），Invoke会抛出异常。因此，我建议您在致电InvokeRequired或Invoke之前始终查看BeginInvoke。
答案 32 :(得分：6)
我无法在这个丑陋的实现背后获得微软的逻辑，但你必须有两个功能：
void setEnableLoginButton()
{
if (InvokeRequired)
{
// btn_login can be any conroller, (label, button textbox ..etc.)
btn_login.Invoke(new MethodInvoker(setEnable));
// OR
//Invoke(new MethodInvoker(setEnable));
}
else {
setEnable();
}
}
void setEnable()
{
btn_login.Enabled = isLoginBtnEnabled;
}
这些片段对我有用，所以我可以在另一个线程上做一些事情，然后我更新GUI：
Task.Factory.StartNew(()=>
{
// THIS IS NOT GUI
Thread.Sleep(5000);
// HERE IS INVOKING GUI
btn_login.Invoke(new Action(() => DoSomethingOnGUI()));
});
private void DoSomethingOnGUI()
{
// GUI
MessageBox.Show("message", "title", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
更简单：
btn_login.Invoke(new Action(()=>{ /* HERE YOU ARE ON GUI */ }));
答案 33 :(得分：6)
即使操作很耗时（在我的示例中为thread.sleep） - 此代码也不会锁定您的UI：
private void button1_Click(object sender, EventArgs e)
{
Thread t = new Thread(new ThreadStart(ThreadJob));
t.IsBackground = true;
t.Start();
}
private void ThreadJob()
{
string newValue= "Hi";
Thread.Sleep(2000);
this.Invoke((MethodInvoker)delegate
{
label1.Text = newValue;
});
}
答案 34 :(得分：5)
这是一个使用更多功能风格的古老问题的新面貌。如果您在所有项目中保留TaskXM类，那么您只需要一行代码就可以再次担心跨线程更新。
public class Example
{
/// <summary>
/// No more delegates, background workers, etc. Just one line of code as shown below.
/// Note it is dependent on the Task Extension method shown next.
/// </summary>
public async void Method1()
{
// Still on the GUI thread here if the method was called from the GUI thread
// This code below calls the extension method which spins up a new task and calls back.
await TaskXM.RunCodeAsync(() =>
{
// Running an asynchronous task here
// Cannot update the GUI thread here, but can do lots of work
});
// Can update GUI on this line
}
}
/// <summary>
/// A class containing extension methods for the Task class
/// </summary>
public static class TaskXM
{
/// <summary>
/// RunCodeAsyc is an extension method that encapsulates the Task.run using a callback
/// </summary>
/// <param name="Code">The caller is called back on the new Task (on a different thread)</param>
/// <returns></returns>
public async static Task RunCodeAsync(Action Code)
{
await Task.Run(() =>
{
Code();
});
return;
}
}
答案 35 :(得分：5)
也许有点过量，但这是我正常解决这个问题的方式：
由于同步，此处不需要调用。 BasicClassThreadExample只是我的一种布局，因此请根据您的实际需要进行更改。
这很简单，因为你不需要处理UI线程中的东西！
public partial class Form1 : Form
{
BasicClassThreadExample _example;
public Form1()
{
InitializeComponent();
_example = new BasicClassThreadExample();
_example.MessageReceivedEvent += _example_MessageReceivedEvent;
}
void _example_MessageReceivedEvent(string command)
{
listBox1.Items.Add(command);
}
private void button1_Click(object sender, EventArgs e)
{
listBox1.Items.Clear();
_example.Start();
}
}
public class BasicClassThreadExample : IDisposable
{
public delegate void MessageReceivedHandler(string msg);
public event MessageReceivedHandler MessageReceivedEvent;
protected virtual void OnMessageReceivedEvent(string msg)
{
MessageReceivedHandler handler = MessageReceivedEvent;
if (handler != null)
{
handler(msg);
}
}
private System.Threading.SynchronizationContext _SynchronizationContext;
private System.Threading.Thread _doWorkThread;
private bool disposed = false;
public BasicClassThreadExample()
{
_SynchronizationContext = System.ComponentModel.AsyncOperationManager.SynchronizationContext;
}
public void Start()
{
_doWorkThread = _doWorkThread ?? new System.Threading.Thread(dowork);
if (!(_doWorkThread.IsAlive))
{
_doWorkThread = new System.Threading.Thread(dowork);
_doWorkThread.IsBackground = true;
_doWorkThread.Start();
}
}
public void dowork()
{
string[] retval = System.IO.Directory.GetFiles(@"C:\Windows\System32", "*.*", System.IO.SearchOption.TopDirectoryOnly);
foreach (var item in retval)
{
System.Threading.Thread.Sleep(25);
_SynchronizationContext.Post(new System.Threading.SendOrPostCallback(delegate(object obj)
{
OnMessageReceivedEvent(item);
}), null);
}
}
protected virtual void Dispose(bool disposing)
{
if (!disposed)
{
if (disposing)
{
_doWorkThread.Abort();
}
disposed = true;
}
}
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
~BasicClassThreadExample() { Dispose(false); }
}
答案 36 :(得分：5)
关于这个主题的另一个例子：我创建了一个抽象类UiSynchronizeModel，它包含一个常见的方法实现：
public abstract class UiSynchronizeModel
{
private readonly TaskScheduler uiSyncContext;
private readonly SynchronizationContext winformsOrDefaultContext;
protected UiSynchronizeModel()
{
this.winformsOrDefaultContext = SynchronizationContext.Current ?? new SynchronizationContext();
this.uiSyncContext = TaskScheduler.FromCurrentSynchronizationContext();
}
protected void RunOnGuiThread(Action action)
{
this.winformsOrDefaultContext.Post(o => action(), null);
}
protected void CompleteTask(Task task, TaskContinuationOptions options, Action<Task> action)
{
task.ContinueWith(delegate
{
action(task);
task.Dispose();
}, CancellationToken.None, options, this.uiSyncContext);
}
}
您的模型或控制器类应该从此抽象类派生。您可以使用任何模式（任务或手动管理的后台线程）并使用以下方法：
public void MethodThatCalledFromBackroundThread()
{
this.RunOnGuiThread(() => {
// Do something over UI controls
});
}
任务示例：
var task = Task.Factory.StartNew(delegate
{
// Background code
this.RunOnGuiThread(() => {
// Do something over UI controls
});
});
this.CompleteTask(task, TaskContinuationOptions.OnlyOnRanToCompletion, delegate
{
// Code that can safely use UI controls
});
答案 37 :(得分：4)
基本上，无论框架版本或GUI底层库类型如何解决此问题的方法是保存控件，为工作线程创建线程的同步上下文，该线程将编组控件从工作线程到GUI线程的相关交互消息队列。
示例：
SynchronizationContext ctx = SynchronizationContext.Current; // From control
ctx.Send\Post... // From worker thread
答案 38 :(得分：3)
我更喜欢这个：
private void UpdateNowProcessing(string nowProcessing)
{
if (this.InvokeRequired)
{
Action<string> d = UpdateNowProcessing;
Invoke(d, nowProcessing);
}
else
{
this.progressDialog.Next(nowProcessing);
}
}
答案 39 :(得分：3)
首先获取表单的实例（在本例中为mainForm），然后在另一个线程中使用此代码。
mainForm.Invoke(new MethodInvoker(delegate ()
{
// Update things in my mainForm here
mainForm.UpdateView();
}));
答案 40 :(得分：3)
将一些公共变量放在一个单独的类中以保存该值。
示例：
public class data_holder_for_controls
{
// It will hold the value for your label
public string status = string.Empty;
}
class Demo
{
public static data_holder_for_controls d1 = new data_holder_for_controls();
static void Main(string[] args)
{
ThreadStart ts = new ThreadStart(perform_logic);
Thread t1 = new Thread(ts);
t1.Start();
t1.Join();
//your_label.Text=d1.status; --- can access it from any thread
}
public static void perform_logic()
{
// Put some code here in this function
for (int i = 0; i < 10; i++)
{
// Statements here
}
// Set the result in the status variable
d1.status = "Task done";
}
}
答案 41 :(得分：3)
还有另一个通用的 Control 扩展方法。
首先为 Control
类型的对象添加扩展方法public static void InvokeIfRequired<T>(this T c, Action<T> action) where T : Control
{
if (c.InvokeRequired)
{
c.Invoke(new Action(() => action(c)));
}
else
{
action(c);
}
}
并从另一个线程这样调用以访问UI线程中名为Object1的控件：
object1.InvokeIfRequired(c => { c.Visible = true; });
object1.InvokeIfRequired(c => { c.Text = "ABC"; });
..或类似的
object1.InvokeIfRequired(c =>
{
c.Text = "ABC";
c.Visible = true;
}
);
答案 42 :(得分：2)
就我而言（WPF），解决方案很简单：
private void updateUI()
{
if (!Dispatcher.CheckAccess())
{
Dispatcher.BeginInvoke(updateUI);
return;
}
// Update any number of controls here
}
答案 43 :(得分：2)
只使用ui的同步上下文
using System.Threading;
// ...
public partial class MyForm : Form
{
private readonly SynchronizationContext uiContext;
public MyForm()
{
InitializeComponent();
uiContext = SynchronizationContext.Current; // get ui thread context
}
private void button1_Click(object sender, EventArgs e)
{
Thread t = new Thread(() =>
{// set ui thread context to new thread context
// for operations with ui elements to be performed in proper thread
SynchronizationContext
.SetSynchronizationContext(uiContext);
label1.Text = "some text";
});
t.Start();
}
}
答案 44 :(得分：1)
一般方法是：
using System;
using System.Threading;
using System.Windows.Forms;
namespace WindowsFormsApp1
{
public partial class Form1 : Form
{
int clickCount = 0;
public Form1()
{
InitializeComponent();
label1.SetText("0");
}
private void button1_Click(object sender, EventArgs e)
{
new Thread(() => label1.SetText((++clickCount).ToString())).Start();
}
}
public static class ControlExtensions
{
public static void SetText(this Control control, string text)
{
if (control.InvokeRequired)
control.Invoke(setText, control, text);
else
control.Text = text;
}
private static readonly Action<Control, string> setText =
(control, text) => control.Text = text;
}
}
说明：
答案很像this one。但是使用整洁（对我而言）和较新的语法。关键是InvokeRequired的{{1}}属性。它获得一个值，该值指示在对控件进行方法调用时调用者是否必须调用invoke方法，因为调用者所在的线程与控件创建所在的线程不同。因此，如果我们在创建线程control的同一线程上调用control.SetText("some text")，只需将control设置为此Text就可以了。但是，在任何其他线程上，它都会导致control.Text = text，因此必须通过System.InvalidOperationException调用一种方法才能在创建线程control.Invoke(...)上设置Text。
答案 45 :(得分：0)
最简单的方法是调用如下：
Application.Current.Dispatcher.Invoke(new Action(() =>
{
try
{
///
}
catch (Exception)
{
//
}
}
));
答案 46 :(得分：-1)
要在WPF中实现这一点，我可以通过以下方式实现。
new Thread(() =>
{
while (...)
{
SomeLabel.Dispatcher.BeginInvoke((Action)(() => SomeLabel.Text = ...));
}
}).Start();