您可以使用现有的委托操作：

private void UpdateMethod()
{
    if (InvokeRequired)
    {
        Invoke(new Action(UpdateMethod));
    }
}

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

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

}

处理长工作

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

关于这个主题的另一个示例：我创建了一个抽象类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
});

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

绝大多数答案使用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代码的情况。