您只需要使用Invoke或BeginInvoke来完成更改UI所需的最小工作量。你的“heavy”方法应该在另一个线程上执行(例如通过BackgroundWorker)，然后使用Control. invoke /Control。BeginInvoke来更新UI。这样你的UI线程就可以自由地处理UI事件等。

关于WinForms的例子，请参阅我的线程文章——尽管这篇文章是在BackgroundWorker出现之前写的，恐怕我还没有在这方面更新它。BackgroundWorker只是稍微简化了一下回调。

. net中的控件通常不是线程安全的。这意味着您不应该从其他线程访问控件，而不是它所在的线程。为了解决这个问题，您需要调用控件，这就是第二个示例所尝试的。

然而，在您的例子中，您所做的只是将长时间运行的方法传递回主线程。当然，这并不是你真正想做的。你需要重新思考这一点，以便你在主线程上所做的一切都是在这里和那里设置一个快速属性。

当我在xamarin工作室外的一个visual studio winforms原型项目中编程iOS-Phone单触摸应用程序控制器时，我发现了这个需求。比起xamarin studio，我更倾向于在VS中编程，我希望控制器能够与手机框架完全分离。通过这种方式，在Android和Windows Phone等其他框架上实现这个功能将更容易用于未来的使用。

我想要一种解决方案，使GUI可以响应事件，而无需处理每次单击按钮背后的跨线程切换代码。基本上让类控制器来处理，以保持客户端代码简单。你可能在GUI上有很多事件，如果你可以在类的一个地方处理它，会更干净。我不是一个多头专家，让我知道，如果这是有缺陷的。

public partial class Form1 : Form
{
    private ExampleController.MyController controller;

    public Form1()
    {          
        InitializeComponent();
        controller = new ExampleController.MyController((ISynchronizeInvoke) this);
        controller.Finished += controller_Finished;
    }

    void controller_Finished(string returnValue)
    {
        label1.Text = returnValue; 
    }

    private void button1_Click(object sender, EventArgs e)
    {
        controller.SubmitTask("Do It");
    }
}

GUI表单不知道控制器正在运行异步任务。

public delegate void FinishedTasksHandler(string returnValue);

public class MyController
{
    private ISynchronizeInvoke _syn; 
    public MyController(ISynchronizeInvoke syn) {  _syn = syn; } 
    public event FinishedTasksHandler Finished; 

    public void SubmitTask(string someValue)
    {
        System.Threading.ThreadPool.QueueUserWorkItem(state => submitTask(someValue));
    }

    private void submitTask(string someValue)
    {
        someValue = someValue + " " + DateTime.Now.ToString();
        System.Threading.Thread.Sleep(5000);
//Finished(someValue); This causes cross threading error if called like this.

        if (Finished != null)
        {
            if (_syn.InvokeRequired)
            {
                _syn.Invoke(Finished, new object[] { someValue });
            }
            else
            {
                Finished(someValue);
            }
        }
    }
}

同样的问题:如何从c中的另一个线程更新gui

两种方式:

在e.result中返回值，并使用它来设置backgroundWorker_RunWorkerCompleted事件的文本框值 在一个单独的类中声明一些变量来保存这些类型的值(它将作为数据持有者)。创建该类的静态实例，您可以在任何线程上访问它。

例子:

public  class data_holder_for_controls
{
    //it will hold value for your label
    public  string status = string.Empty;
}

class Demo
{
    public static  data_holder_for_controls d1 = new data_holder_for_controls();
    static void Main(string[] args)
    {
        ThreadStart ts = new ThreadStart(perform_logic);
        Thread t1 = new Thread(ts);
        t1.Start();
        t1.Join();
        //your_label.Text=d1.status; --- can access it from any thread 
    }

    public static void perform_logic()
    {
        //put some code here in this function
        for (int i = 0; i < 10; i++)
        {
            //statements here
        }
        //set result in status variable
        d1.status = "Task done";
    }
}

例如，从UI线程的控件中获取文本:

Private Delegate Function GetControlTextInvoker(ByVal ctl As Control) As String

Private Function GetControlText(ByVal ctl As Control) As String
    Dim text As String

    If ctl.InvokeRequired Then
        text = CStr(ctl.Invoke(
            New GetControlTextInvoker(AddressOf GetControlText), ctl))
    Else
        text = ctl.Text
    End If

    Return text
End Function

UI中的线程模型

为了理解基本概念，请阅读UI应用程序中的线程模型(旧的VB链接在这里)。该链接导航到描述WPF线程模型的页面。但是，Windows窗体利用了相同的思想。

UI线程

只有一个线程(UI线程)被允许访问System.Windows.Forms.Control及其子类成员。 试图从不同的线程访问System.Windows.Forms.Control的成员会导致跨线程异常。 因为只有一个线程，所以所有的UI操作都作为工作项进入该线程:

如果UI线程没有工作，那么就存在空闲间隙，可以由与UI无关的计算使用。 为了使用上述间隙，请使用System.Windows.Forms.Control.Invoke或System.Windows.Forms.Control.BeginInvoke方法:

BeginInvoke和Invoke方法

The computing overhead of method being invoked should be small as well as computing overhead of event handler methods because the UI thread is used there - the same that is responsible for handling user input. Regardless if this is System.Windows.Forms.Control.Invoke or System.Windows.Forms.Control.BeginInvoke. To perform computing expensive operation always use separate thread. Since .NET 2.0 BackgroundWorker is dedicated to performing computing expensive operations in Windows Forms. However in new solutions you should use the async-await pattern as described here. Use System.Windows.Forms.Control.Invoke or System.Windows.Forms.Control.BeginInvoke methods only to update a user interface. If you use them for heavy computations, your application will block:

调用

System.Windows.Forms.Control.Invoke导致单独的线程等待，直到调用的方法完成:

BeginInvoke

System.Windows.Forms.Control.BeginInvoke不会导致单独的线程等待被调用的方法完成:

代码的解决方案

阅读问题的答案如何更新GUI从另一个线程在c# ? 对于c# 5.0和。net 4.5，推荐的解决方案在这里。