C# 如何从另一个线程更新GUI？
从另一个线程更新标签的最简单方法是什么 我在thread1上运行了一个表单，然后我开始了另一个thread2线程 当thread2正在处理一些文件时，我想用thread2工作的当前状态更新表单上的标签C# 如何从另一个线程更新GUI？,c#,.net,multithreading,winforms,user-interface,C#,.net,Multithreading,Winforms,User Interface,从另一个线程更新标签的最简单方法是什么 我在thread1上运行了一个表单，然后我开始了另一个thread2线程 当thread2正在处理一些文件时，我想用thread2工作的当前状态更新表单上的标签 我该怎么做呢？您必须确保更新发生在正确的线程上；用户界面线程 为了做到这一点，您必须调用事件处理程序，而不是直接调用它 您可以通过以下方式提高您的活动： // thread-safe equivalent of // myLabel.Text = status; SetControlPropert
我该怎么做呢？您必须确保更新发生在正确的线程上；用户界面线程 为了做到这一点，您必须调用事件处理程序，而不是直接调用它 您可以通过以下方式提高您的活动：
// thread-safe equivalent of
// myLabel.Text = status;
SetControlPropertyThreadSafe(myLabel, "Text", status);
myButton.SetPropertyInGuiThread(b => b.Text, "Click Me!")
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
}
this.Invoke((MethodInvoker)delegate
{
progressBar1.Value = e.ProgressPercentage; // runs on UI thread
});
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 ( ... );
}
}
}
MyEvent.Raise(this, EventArgs.Empty);
当然，您也可以使用BackGroundWorker类，它将为您抽象这个问题。简单的解决方案是使用Control.Invoke
您需要在GUI线程上调用该方法。您可以通过调用Control.Invoke来实现这一点 例如：
delegate void UpdateLabelDelegate (string message);
void UpdateLabel (string message)
{
if (InvokeRequired)
{
Invoke (new UpdateLabelDelegate (UpdateLabel), message);
return;
}
MyLabelControl.Text = message;
}
请注意，Invoke会阻止执行，直到它完成这是一个同步代码。这个问题不涉及异步代码，但当您想了解异步代码时，有很多关于编写异步代码的问题。这是您应该采用的经典方法：
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中，您需要跨线程来更改实际控件。。。类似于标签或进度条。对于.NET 2.0，下面是我编写的一段代码，它完全符合您的要求，适用于控件上的任何属性： 可以这样称呼：
// thread-safe equivalent of
// myLabel.Text = status;
SetControlPropertyThreadSafe(myLabel, "Text", status);
myButton.SetPropertyInGuiThread(b => b.Text, "Click Me!")
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
}
this.Invoke((MethodInvoker)delegate
{
progressBar1.Value = e.ProgressPercentage; // runs on UI thread
});
myLabel.SetPropertyThreadSafe("Text", status);
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 });
}
}
myLabel.SetPropertyThreadSafe(() => aForm.ShowIcon, false);
如果有人对如何改进此代码以提高编译时安全性有任何进一步的建议，请发表评论 出于许多目的，它就这么简单：
public delegate void serviceGUIDelegate();
private void updateGUI()
{
this.Invoke(new serviceGUIDelegate(serviceGUI));
}
serviceGUI是表单中的GUI级方法，可以根据需要更改任意多个控件。从另一个线程调用updateGUI。可以将参数添加到传递值中，或者如果访问它们的线程之间存在可能导致不稳定的冲突，则可以根据需要更快地使用带有锁的类作用域变量。如果非GUI线程是时间关键型的，请使用BeginInvoke而不是Invoke，记住Brian Gideon的警告 由于场景的琐碎性，我实际上会让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...";
}
}
}
线程代码通常有缺陷，并且总是很难测试。从后台任务更新用户界面不需要编写线程代码。只需使用类来运行任务，并使用它的方法来更新用户界面。通常，您只报告一个完成百分比，但还有另一个重载包含一个状态对象。下面是一个仅报告字符串对象的示例：
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();
}
最后一件事，请确保设置WorkerReportsProgress标志，否则ReportProgress方法将被完全忽略。为.NET 3.5启动并忘记扩展方法+
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();
}
}
}
这个解决方案类似于上面使用.NETFramework 3.0的解决方案，但它解决了编译时安全支持的问题 如果用户传递错误的数据类型，编译器将失败
this.lblTimeDisplay.SetPropertyValue(a => a.Visible, "sometext");
这是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);
}
否则，原始版本是一个非常好的解决方案。Salvete！在寻找这个问题之后，我发现弗兰克和俄勒冈州幽灵的答案对我来说是最简单最有用的。现在，我用Visual Basic编写代码，并通过转换器运行此代码段；所以我不确定结果如何 我有一个名为form_Diagnostics的对话框，它有一个名为updateDiagWindow的richtext框，我使用它作为一种日志显示。我需要能够从所有线程更新它的文本。额外的行允许窗口自动滚动到最新的行 因此，我现在可以用一行更新显示，从整个程序的任何地方，以您认为的方式，在没有任何线程的情况下工作：
form_Diagnostics.updateDiagWindow(whatmessage);
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!
}
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!
}
Label lblText; //initialized elsewhere
void AssignLabel(string text)
{
if (InvokeRequired)
{
BeginInvoke((Action<string>)AssignLabel, text);
return;
}
lblText.Text = text;
}
control.Invoke((MethodInvoker) (() => control.Text = "new text"));
control.Invoke(new Action(() => control.Text = "new text"));
请参见此处以了解两者的比较：您可以使用现有的委托操作：
当我遇到同样的问题时，我向谷歌寻求帮助，但没有给我一个简单的解决方案，而是举了MethodInvoker和诸如此类的例子，让我更加困惑。所以我决定自己解决这个问题。以下是我的解决方案：
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);
}
// thread-safe equivalent of
// myLabel.Text = status;
SetControlPropertyThreadSafe(myLabel, "Text", status);
myButton.SetPropertyInGuiThread(b => b.Text, "Click Me!")
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
}
this.Invoke((MethodInvoker)delegate
{
progressBar1.Value = e.ProgressPercentage; // runs on UI thread
});
Thread th = new Thread(() => Updatelabel("Hello World"));
th.start();
object1.InvokeIfRequired(c =>
{
c.Text = "ABC";
c.Visible = true;
}
);
不要与Thread=>……混淆。。。。。。在线程上工作时，我使用匿名函数或lambda表达式。要减少代码行数，可以使用ThreadStart。。方法，我不想在这里解释。前面答案中的调用内容都不是必需的 您需要查看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
}
尝试使用以下命令刷新标签：
public static class ExtensionMethods
{
private static Action EmptyDelegate = delegate() { };
public static void Refresh(this UIElement uiElement)
{
uiElement.Dispatcher.Invoke(DispatcherPriority.Render, EmptyDelegate);
}
}
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";
}
必须使用invoke和delegate
private delegate void MyLabelDelegate();
label1.Invoke( new MyLabelDelegate(){ label1.Text += 1; });
SynchronizationContext _context;
var _context = SynchronizationContext.Current;
_context.Send(status =>{
// UPDATE LABEL
}, null);
例如，访问当前线程以外的控件：
Speed_Threshold = 30;
textOutput.Invoke(new EventHandler(delegate
{
lblThreshold.Text = Speed_Threshold.ToString();
}));
lblThreshold是一个标签，Speed_Threshold是一个全局变量。当您在UI线程中时，可以向它请求其同步上下文任务调度器。它将为您提供一个调度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;
}
}
这适用于任务，而不是线程。绝大多数答案都使用Control.Invoke，这是一种。例如，考虑公认的答案：
string newText = "abc"; // running on worker thread
this.Invoke((MethodInvoker)delegate {
someLabel.Text = newText; // runs on UI thread
});
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.5及更高版本上，您还可以使用Progress，它基本上捕获SynchronizationContext.Current（同步上下文创建时的当前状态），如所示，对于长时间运行的操作需要在仍然工作的情况下运行UI代码的情况。只需使用以下内容：
// thread-safe equivalent of
// myLabel.Text = status;
SetControlPropertyThreadSafe(myLabel, "Text", status);
myButton.SetPropertyInGuiThread(b => b.Text, "Click Me!")
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
}
this.Invoke((MethodInvoker)delegate
{
progressBar1.Value = e.ProgressPercentage; // runs on UI thread
});
WPF应用程序中最简单的方法是：
this.Dispatcher.Invoke((Action)(() =>
{
// This refers to a form in a WPF application
val1 = textBox.Text; // Access the UI
}));
对于这个问题，大多数其他答案对我来说都有点复杂。我对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"));
}
txtLog.Invoke((MethodInvoker)delegate
{
txtLog.Text = "my message";
});
workerAllocator.DoWork += delegate (object sender1, DoWorkEventArgs e1)
{
// The below single line works
txtLog.Dispatcher.BeginInvoke((Action)(() => txtLog.Text = "my message"));
}
txtLog.Invoke((MethodInvoker)delegate
{
txtLog.Text = "my message";
});
Thread th = new Thread(() => Updatelabel("Hello World"));
th.start();
object1.InvokeIfRequired(c =>
{
c.Text = "ABC";
c.Visible = true;
}
);
的确如此，但我不想因为这件事而“弄乱”我的GUI代码。我的GUI不应该关心是否需要调用。换句话说：我不认为GUI有责任执行上下文转换。将委托分离等似乎有些过分-为什么不只是：SynchronizationContext.Current.Senddelegate{MyEvent…；}，null；您是否始终可以访问SynchronizationContext？即使您的类在类库中？因为OP没有提到除表单之外的任何类/实例，所以这是一个不错的默认值…不要忘记this关键字正在引用控件类。@code完成这两种方式都是安全的，而且我们已经知道我们使用的是worker，那么，为什么要检查我们知道的东西呢？@Dragouf实际上不是这样-使用此方法的一个要点是，您已经知道哪些部分在worker上运行，哪些部分在UI线程上运行。不需要检查。@John，因为Control.Invoke对任何委托都是这样做的-不仅仅是一个非方法调用行给了我一个编译器错误。与“System.Windows.Forms.Control.InvokeSystem.Delegate，object[]”匹配的最佳重载方法具有一些无效参数。有时，this.GetType的计算结果与propertyInfo.ReflectedType相同，例如WinForms上的LinkLabel。我没有大型C语言的经验，但我认为异常的条件应该是：if propertyInfo==null | |@this.GetType.IsSubclassOfpropertyInfo.ReflectedType&&@this.GetType！=propertyInfo.ReflectedType | |@this.GetType.GetPropertypropertyInfo.Name，propertyInfo.PropertyType==null@lan是否可以从其他模块或类或表单调用此SetControlPropertyThreadSafeMailLabel、Text、status？提供的解决方案过于复杂。如果您重视简单性，请参阅Marc Gravell的解决方案或Zaid Masud的解决方案。如果您更新多个属性，此解决方案会浪费大量资源，因为每次调用都会耗费大量资源。我不认为这是线程安全特性的初衷。请封装您的UI更新操作并调用它一次，而不是每个属性。您究竟会在BackgroundWorker组件上使用此代码吗？难道.net 2.0+没有BackgroundWorker类仅用于此目的吗。它支持UI线程感知。1.创建一个BackgroundWorker 2。添加两个代理—一个用于处理，一个用于完成—可能有点晚：请参见.NET 4.5和C 5.0的答案：此问题不适用于Gtk GUI。对于Gtk，请参阅并回答。注意：这个问题的答案现在是一堆杂乱无章的OT。以下是我为我的WPF应用程序和历史.NET 2.0工件所做的操作。@this用法的意义是什么？控制难道不是等价的吗？有本吗
efits to@this？@jeromeyers，-@this只是变量名，在本例中是对调用扩展名的当前控件的引用。你可以把它改名为source，或者任何能让你的船漂浮的东西。我使用@this，因为它指的是调用扩展的“this Control”，在我的脑海中是一致的，至少在正常的非扩展代码中使用了“this”关键字。这很好，很简单，对我来说是最好的解决方案。您可以在ui线程中包含所有必须完成的工作。示例：this.UIThread=>{txtMessage.Text=message；listBox1.Items.Addmessage；}；我真的很喜欢这个解决方案。次要缺点：我想把这个方法命名为OnUIThread而不是UIThread。这就是为什么我把这个扩展命名为rununuithread。但这只是个人品味。好主意。您唯一没有提到的是如何在WorkerThread完成后正确处理计时器。注意：当应用程序结束时，即用户关闭应用程序时，这可能会导致问题。您知道如何解决此问题吗？@Matt您使用成员方法，而不是使用已用事件的匿名处理程序，以便在释放表单时删除计时器…@Phil1970-这一点很好。您的意思是像System.Timers.ElapsedEventHandler handler=s，a=>{MyProgressLabel.Text=m_Text；}；并通过m_Timer.appeased+=handler；分配它；，稍后在dispose上下文中执行m_Timer.appeased-=处理程序；我说得对吗？如果SecondThreadConcern.LongWork引发异常，则调用Task.Start通常不是一个好的做法，UI线程是否可以捕获该异常？顺便说一句，这是一篇很好的帖子。我在答案中增加了一个部分来满足你的要求。注意。在异步等待模式中，用户界面线程上的后台异常被重新触发，这是不是因为我认为这种方式比调用Invoke/Begin更冗长？！Task.Delay500.等等？创建一个任务来阻止当前线程有什么意义？永远不要阻止线程池线程！做得好，简单！不仅简单，而且效果很好！我真的不明白为什么微软不能让它变得更简单，因为它是注定的！为了在主线程上调用一行，我们应该编写两个函数@MBH同意。顺便说一句，你们注意到上面的答案了吗？它定义了一个扩展方法？在自定义实用程序类中这样做一次，就不必再关心微软没有为我们这样做：@ToolmakerSteve这正是它的本意！你是对的，我们可以找到一种方法，但我的意思是，从DRY的观点来看，有共同解决方案的问题，可以由微软以最小的努力解决，这将为程序员节省大量时间：如果你有e.ProgressPercentage，您不是已经从调用此方法的方法进入UI线程了吗？ProgressChanged事件在UI线程上运行。这是使用BackgroundWorker的便利之一。完成的事件也在gui上运行。非UI线程中唯一运行的是DoWork方法。在处理结束时，还可以通过backgroundWorker1\u RunWorkerCompleted更新用户界面。您认为Post方法在幕后使用什么如果您使用的是WPF应用程序，则这是正确的。但是他使用的是Windows窗体。你甚至可以在Winforms应用程序中使用Dispatcher。本例中的“控制”是什么？我的UI控件？试图在label控件的WPF中实现此功能，而Invoke不是我的标签的成员。像@styxriver这样的扩展方法如何？声明“Action y；”在类或方法内部更改文本属性并使用以下代码段更新文本“yourcontrol.Invokey==>yourcontrol.text=newtext；”@Dbloom它不是成员，因为它仅用于WinForms。对于WPF，您使用Dispatcher.InvokeI遵循此解决方案，但有时我的UI没有得到更新。我发现我需要这个.refresh来强制失效并重新绘制GUI。。如果有帮助的话..是针对Windows窗体的吗？问题是关于Winforms，而不是WPF。谢谢。上面添加了WinForms解决方案…这只是关于同一问题的许多其他答案的副本，但还可以。为什么不成为解决方案的一部分并删除你的答案呢？嗯，你是正确的，如果你专心阅读我的答案，开头部分就是我写答案的原因，希望你能更专心一点，看到有人有完全相同的问题&今天对我的简单答案投了赞成票，如果你能预见到这一切发生的真实原因，那就是谷歌甚至在我搜索wpf的时候把我送到这里。当然，既然你错过了这三个或多或少明显的原因，我可以理解你为什么不取消你的否决票。而不是清洁好的，创造一些新的，这是非常困难的。非常优雅，非常好！我已经开始你了 使用c.BeginInvoke进行异步更新。如果在级联中调用，则不太可能导致死锁。