为了在WPF中实现这一点，我采用以下方式。

 new Thread(() => 
 {
     while (...)
     {
         SomeLabel.Dispatcher.BeginInvoke((Action)(() => SomeLabel.Text = ...));
     }
 }).Start();

我的版本是插入一行递归的“咒语”：

对于无参数：

    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!
    }

就是这样。

一些论证：通常在if（）语句后一行放置{}对代码可读性不利。但在这种情况下，这是例行的“咒语”。如果此方法在项目中保持一致，则不会破坏代码的可读性。它还可以避免代码乱丢（一行代码而不是五行代码）。

当您看到（InvokeRequired）｛some long｝时，您只知道“从另一个线程调用此函数是安全的”。

为了在WPF中实现这一点，我采用以下方式。

 new Thread(() => 
 {
     while (...)
     {
         SomeLabel.Dispatcher.BeginInvoke((Action)(() => SomeLabel.Text = ...));
     }
 }).Start();

当您在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;
  }
}

这适用于任务（而不是线程），这是目前编写并发代码的首选方式。

您需要在GUI线程上调用该方法。您可以通过调用Control.Invoke来实现这一点。

例如：

delegate void UpdateLabelDelegate (string message);

void UpdateLabel (string message)
{
    if (InvokeRequired)
    {
         Invoke (new UpdateLabelDelegate (UpdateLabel), message);
         return;
    }

    MyLabelControl.Text = message;
}

处理长工作

由于.NET 4.5和C#5.0，您应该在所有领域（包括GUI）使用基于任务的异步模式（TAP）和异步等待关键字：

TAP是新开发推荐的异步设计模式

而不是异步编程模型（APM）和基于事件的异步模式（EAP）（后者包括BackgroundWorker类）。

那么，新开发的建议解决方案是：

事件处理程序的异步实现（是的，仅此而已）：私有异步void Button_Clicked（对象发送方，EventArgs e）{var progress=new progress＜string＞（s＝＞label.Text＝s）；await Task.Factory.StartNew（（）=>SecondThreadConcern.LongWork（进度），TaskCreationOptions.LongRunning）；label.Text=“已完成”；}通知UI线程的第二个线程的实现：类SecondThreadConcern{公共静态void LongWork（IProgress＜string＞进度）{//进行长时间的工作。。。对于（变量i=0；i<10；i++）{任务.延迟（500）.等待（）；progress.Report（i.ToString（））；}}}

请注意以下事项：

以顺序方式编写的简短而干净的代码，没有回调和显式线程。任务而不是线程。async关键字，它允许使用await，从而防止事件处理程序在任务完成之前达到完成状态，同时不会阻塞UI线程。进程类（参见IProgress接口），支持关注点分离（SoC）设计原则，不需要显式调度程序和调用。它使用创建位置（此处为UI线程）的当前SynchronizationContext。TaskCreationOptions.LongRunning，提示不要将任务排入ThreadPool。

有关更详细的示例，请参阅约瑟夫·阿尔巴哈里（Joseph Albahari）的《C#的未来：美好的事物降临在那些“等待”的人身上》。

另请参见UI线程模型概念。

异常处理

下面的代码片段是如何处理异常和切换按钮的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...");
    }
}