这是一个古老问题的新视角，使用了更实用的风格。如果您在所有项目中都保留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;
    }
}

我刚读了答案，这似乎是一个非常热门的话题。我目前正在使用.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，可以选择等待一段明确定义的时间（超时）。

绝大多数答案使用Control.Invoke，这是等待发生的竞争条件。例如，考虑接受的答案：

string newText = "abc"; // running on worker thread
this.Invoke((MethodInvoker)delegate { 
    someLabel.Text = newText; // runs on UI thread
});

如果用户在调用this.Invoke之前关闭表单（请记住，这是form对象），则可能会触发ObjectDisposedException。

解决方案是使用SynchronizationContext，特别是hamilton.danielb建议的SynchronizaionContext.Current（其他答案依赖于特定的Synchronization Context实现，这是完全不必要的）。我会稍微修改他的代码，使用SynchronizationContext.Post而不是SynchronizazationContext.Send（因为通常不需要工作线程等待）：

public partial class MyForm : Form
{
    private readonly SynchronizationContext _context;
    public MyForm()
    {
        _context = SynchronizationContext.Current
        ...
    }

    private MethodOnOtherThread()
    {
         ...
         _context.Post(status => someLabel.Text = newText,null);
    }
}

请注意，在.NET4.0及更高版本上，您应该真正将任务用于异步操作。有关等效的基于任务的方法（使用TaskScheduler.FromCurrentSynchronizationContext），请参见n-san的答案。

最后，在.NET 4.5及更高版本上，您还可以使用Progress＜T＞（它基本上在创建时捕获SynchronizationContext.Current），正如Ryszard Dżegan所演示的，用于长时间运行的操作需要在运行时运行UI代码的情况。

只需使用以下内容：

 this.Invoke((MethodInvoker)delegate
            {
                progressBar1.Value = e.ProgressPercentage; // runs on UI thread
            });

创建类变量：

SynchronizationContext _context;

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

var _context = SynchronizationContext.Current;

要更新标签时：

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

也许有点过量，但这是我通常解决问题的方式：

由于同步，此处不需要调用。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); }

}