创建类变量：

SynchronizationContext _context;

在创建UI的构造函数中设置它：

var _context = SynchronizationContext.Current;

要更新标签时：

_context.Send(status =>{
    // UPDATE LABEL
}, null);

线程代码经常有bug，而且总是很难测试。您不需要编写线程代码来从后台任务更新用户界面。只需使用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方法将被完全忽略。

在这个问题上，大多数其他答案对我来说都有点复杂（我是C#新手），所以我写了我的答案：

我有一个WPF应用程序，并定义了如下工作人员：

问题：

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";
});

我刚读了答案，这似乎是一个非常热门的话题。我目前正在使用.NET 3.5 SP1和Windows窗体。

前面的答案中大量描述的使用InvokeRequired属性的著名公式涵盖了大多数情况，但不包括整个池。

如果尚未创建句柄怎么办？

InvokeRequired属性，如这里所述（Control.InvokeRequired属性对MSDN的引用），如果调用是从非GUI线程的线程进行的，则返回true；如果调用是由GUI线程进行的或尚未创建Handle，则返回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!";
}

如果标签更新之前的操作“花费的时间”（阅读并将其解释为简化）少于GUI线程创建表单句柄所花费的时间，则这可能会导致InvalidOperationException。这发生在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!";
}

如果尚未创建handle，您可以处理要执行的操作：您可以忽略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();
  }
}

我用这个ThreadSafeGuidCommand的一个实例为另一个线程更新的表单提供数据，并定义如下更新GUI（在我的表单中）的方法：

public void SetLabeTextTo(string value)
{
  _threadSafeGuiCommand.Execute(this, delegate { Label1.Text = value; });
}

通过这种方式，我很确定无论什么线程进行调用，我都会更新GUI，可以选择等待一段明确定义的时间（超时）。

基本上，无论框架版本或GUI底层库类型如何，解决此问题的方法都是保存控件，为工作线程创建线程的同步上下文，从而将控件的相关交互从工作线程编组到GUI的线程消息队列。

例子：

SynchronizationContext ctx = SynchronizationContext.Current; // From control
ctx.Send\Post... // From worker thread

对于.NET 2.0，下面是我编写的一段代码，它完全符合您的需要，适用于控件上的任何属性：

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);

2010年10月5日更新：

对于.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表达式来允许更干净、更简单和更安全的语法：

// status has to be of type string or this will fail to compile
myLabel.SetPropertyThreadSafe(() => myLabel.Text, status);

现在不仅在编译时检查了属性名称，而且属性的类型也是如此，因此不可能（例如）将字符串值分配给布尔属性，从而导致运行时异常。

不幸的是，这并不能阻止任何人做一些愚蠢的事情，例如传递另一个控件的属性和值，因此以下内容将很好地编译：

myLabel.SetPropertyThreadSafe(() => aForm.ShowIcon, false);

因此，我添加了运行时检查，以确保传入的属性实际上属于调用该方法的控件。虽然不完美，但仍比.NET2.0版本好得多。

如果有人对如何改进此代码以确保编译时安全有任何进一步的建议，请发表评论！