c# - 跨线程操作无效：控件从创建它的线程以外的线程访问

Question

我有一个场景。（Windows 窗体、C#、.NET）

有一个主窗体承载一些用户控件。
用户控件执行一些繁重的数据操作，因此如果我直接调用该UserControl_Load方法，UI 在加载方法执行期间将变得无响应。
为了克服这个问题，我在不同的线程上加载数据（尝试尽可能少地更改现有代码）
我使用了一个后台工作线程，它将加载数据，完成后将通知应用程序它已完成工作。
现在出现了一个真正的问题。所有 UI（主窗体及其子用户控件）都是在主主线程上创建的。在用户控件的 LOAD 方法中，我根据用户控件上的某些控件（如文本框）的值来获取数据。

伪代码如下所示：

代码 1

UserContrl1_LoadDataMethod()
{
    if (textbox1.text == "MyName") // This gives exception
    {
        //Load data corresponding to "MyName".
        //Populate a globale variable List<string> which will be binded to grid at some later stage.
    }
}

它给出的例外是

跨线程操作无效：控件从创建它的线程以外的线程访问。

要了解更多信息，我做了一些谷歌搜索，并提出了一个建议，例如使用以下代码

代码 2

UserContrl1_LoadDataMethod()
{
    if (InvokeRequired) // Line #1
    {
        this.Invoke(new MethodInvoker(UserContrl1_LoadDataMethod));
        return;
    }

    if (textbox1.text == "MyName") // Now it wont give an exception
    {
    //Load data correspondin to "MyName"
        //Populate a globale variable List<string> which will be binded to grid at some later stage
    }
}

但是但是但是……看来我又回到了原点。应用程序再次变得无响应。这似乎是由于第 1 行 if 条件的执行。加载任务再次由父线程完成，而不是我产生的第三个。

我不知道我认为这是对还是错。我是线程新手。

我该如何解决这个问题以及执行 Line#1 if block 的效果是什么？

情况是这样的：我想根据控件的值将数据加载到全局变量中。我不想从子线程更改控件的值。我永远不会从子线程中执行此操作。

所以只有访问该值，以便可以从数据库中获取相应的数据。

score 468 · Accepted Answer

根据Prerak K 的更新评论（已删除）：

我想我没有正确提出这个问题。

情况是这样的：我想根据控件的值将数据加载到全局变量中。我不想从子线程更改控件的值。我永远不会从子线程中执行此操作。

所以只能访问该值，以便可以从数据库中获取相应的数据。

您想要的解决方案应该如下所示：

UserContrl1_LOadDataMethod()
{
    string name = "";
    if(textbox1.InvokeRequired)
    {
        textbox1.Invoke(new MethodInvoker(delegate { name = textbox1.text; }));
    }
    if(name == "MyName")
    {
        // do whatever
    }
}

在尝试切换回控件的线程之前，请在单独的线程中进行认真的处理。例如：

UserContrl1_LOadDataMethod()
{
    if(textbox1.text=="MyName") //<<======Now it wont give exception**
    {
        //Load data correspondin to "MyName"
        //Populate a globale variable List<string> which will be
        //bound to grid at some later stage
        if(InvokeRequired)
        {
            // after we've done all the processing, 
            this.Invoke(new MethodInvoker(delegate {
                // load the control with the appropriate data
            }));
            return;
        }
    }
}

score 204 · Accepted Answer

UI中的线程模型

请阅读UI 应用程序中的线程模型（此处为旧 VB 链接）以了解基本概念。该链接导航到描述 WPF 线程模型的页面。但是，Windows 窗体使用了相同的想法。

用户界面线程

只有一个线程（UI 线程）允许访问System.Windows.Forms.Control及其子类成员。
尝试从不同于 UI 线程的线程访问System.Windows.Forms.Control的成员将导致跨线程异常。
由于只有一个线程，所有 UI 操作都作为工作项排入该线程：

在此处输入图像描述

如果 UI 线程没有工作，那么就有空闲间隙可供非 UI 相关的计算使用。
为了使用提到的差距使用System.Windows.Forms.Control.Invoke或System.Windows.Forms.Control.BeginInvoke方法：

在此处输入图像描述

BeginInvoke 和 Invoke 方法

被调用的方法的计算开销和事件处理程序方法的计算开销应该很小，因为那里使用了 UI 线程 - 与负责处理用户输入的线程相同。不管这是System.Windows.Forms.Control.Invoke还是System.Windows.Forms.Control.BeginInvoke。
要执行计算昂贵的操作，请始终使用单独的线程。由于 .NET 2.0 BackgroundWorker致力于在 Windows 窗体中执行计算昂贵的操作。但是，在新的解决方案中，您应该使用此处描述的 async-await 模式。
仅使用System.Windows.Forms.Control.Invoke或System.Windows.Forms.Control.BeginInvoke方法来更新用户界面。如果您将它们用于繁重的计算，您的应用程序将阻塞：

在此处输入图像描述

调用

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

在此处输入图像描述

开始调用

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

在此处输入图像描述

代码解决方案

阅读有关如何从 C# 中的另一个线程更新 GUI？. 对于 C# 5.0 和 .NET 4.5，推荐的解决方案在这里。

score 75 · Accepted Answer

您只想使用Invoke或BeginInvoke完成更改 UI 所需的最少工作。您的“重”方法应该在另一个线程上执行（例如 via BackgroundWorker），然后使用Control.Invoke/Control.BeginInvoke只是为了更新 UI。这样你的 UI 线程就可以自由地处理 UI 事件等。

有关WinForms 示例，请参阅我的线程文章- 尽管该文章是在到达现场之前编写的，但恐怕我还没有在这方面对其进行更新。只是稍微简化了回调。BackgroundWorkerBackgroundWorker

score 57 · Accepted Answer

我知道现在为时已晚。但是即使在今天，如果您无法访问跨线程控件？这是迄今为止最短的答案：P

Invoke(new Action(() =>
                {
                    label1.Text = "WooHoo!!!";
                }));

这就是我从线程访问任何表单控件的方式。

score 44 · Accepted Answer

我遇到过这个问题，FileSystemWatcher发现下面的代码解决了这个问题：

fsw.SynchronizingObject = this

然后控件使用当前表单对象来处理事件，因此将在同一个线程上。

score 21 · Accepted Answer

我发现需要在与表单相关的所有方法中乱扔的检查和调用代码过于冗长且不需要。这是一个简单的扩展方法，可让您完全取消它：

public static class Extensions
{
    public static void Invoke<TControlType>(this TControlType control, Action<TControlType> del) 
        where TControlType : Control
        {
            if (control.InvokeRequired)
                control.Invoke(new Action(() => del(control)));
            else
                del(control);
    }
}

然后你可以简单地这样做：

textbox1.Invoke(t => t.Text = "A");

没有更多的混乱 - 简单。

score 18 · Accepted Answer

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

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

score 15 · Accepted Answer

UI 跨线程问题的最简洁（也是正确）的解决方案是使用 SynchronizationContext，请参阅Synchronizing calls to UI in a multi-threaded application article，它很好地解释了它。

score 10 · Accepted Answer

按照最简单的（在我看来）方法从另一个线程修改对象：

using System.Threading.Tasks;
using System.Threading;

namespace TESTE
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            Action<string> DelegateTeste_ModifyText = THREAD_MOD;
            Invoke(DelegateTeste_ModifyText, "MODIFY BY THREAD");
        }

        private void THREAD_MOD(string teste)
        {
            textBox1.Text = teste;
        }
    }
}

score 10 · Accepted Answer

使用 Async/Await 和回调的新外观。如果您在项目中保留扩展方法，则只需要一行代码。

/// <summary>
/// A new way to use Tasks for Asynchronous calls
/// </summary>
public class Example
{
    /// <summary>
    /// No more delegates, background workers etc. just one line of code as shown below
    /// Note it is dependent on the XTask class shown next.
    /// </summary>
    public async void ExampleMethod()
    {
        //Still on GUI/Original Thread here
        //Do your updates before the next line of code
        await XTask.RunAsync(() =>
        {
            //Running an asynchronous task here
            //Cannot update GUI Thread here, but can do lots of work
        });
        //Can update GUI/Original thread on this line
    }
}

/// <summary>
/// A class containing extension methods for the Task class 
/// Put this file in folder named Extensions
/// Use prefix of X for the class it Extends
/// </summary>
public static class XTask
{
    /// <summary>
    /// RunAsync 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 RunAsync(Action Code)
    {
        await Task.Run(() =>
        {
            Code();
        });
        return;
    }
}

您可以在 Extension 方法中添加其他内容，例如将其包装在 Try/Catch 语句中，允许调用者告诉它在完成后返回什么类型，对调用者的异常回调：

添加 Try Catch、自动异常记录和回调

    /// <summary>
    /// Run Async
    /// </summary>
    /// <typeparam name="T">The type to return</typeparam>
    /// <param name="Code">The callback to the code</param>
    /// <param name="Error">The handled and logged exception if one occurs</param>
    /// <returns>The type expected as a competed task</returns>

    public async static Task<T> RunAsync<T>(Func<string,T> Code, Action<Exception> Error)
    {
       var done =  await Task<T>.Run(() =>
        {
            T result = default(T);
            try
            {
               result = Code("Code Here");
            }
            catch (Exception ex)
            {
                Console.WriteLine("Unhandled Exception: " + ex.Message);
                Console.WriteLine(ex.StackTrace);
                Error(ex);
            }
            return result;

        });
        return done;
    }
    public async void HowToUse()
    {
       //We now inject the type we want the async routine to return!
       var result =  await RunAsync<bool>((code) => {
           //write code here, all exceptions are logged via the wrapped try catch.
           //return what is needed
           return someBoolValue;
       }, 
       error => {

          //exceptions are already handled but are sent back here for further processing
       });
        if (result)
        {
            //we can now process the result because the code above awaited for the completion before
            //moving to this statement
        }
    }

score 10 · Accepted Answer

这不是解决此错误的推荐方法，但您可以快速抑制它，它会完成工作。对于原型或演示，我更喜欢这个。添加

CheckForIllegalCrossThreadCalls = false

在Form1()构造函数中。

score 8 · Accepted Answer

您需要查看 Backgroundworker 示例： http:
//msdn.microsoft.com/en-us/library/system.componentmodel.backgroundworker.aspx 特别是它如何与 UI 层交互。根据您的帖子，这似乎可以回答您的问题。

score 7 · Accepted Answer

在 xamarin stuidio 之外的 Visual Studio winforms 原型项目中编写 iOS-Phone 单点触控应用程序控制器时，我发现需要这样做。我更喜欢在 VS 中编程而不是 xamarin studio，我希望控制器与手机框架完全解耦。这种方式为其他框架（如 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);
            }
        }
    }
}

score 6 · Accepted Answer

如果您正在使用的对象没有，这是另一种方法

(InvokeRequired)

如果您正在使用主窗体以外的类中的主窗体，并且使用主窗体中的对象但没有 InvokeRequired，这将很有用

delegate void updateMainFormObject(FormObjectType objectWithoutInvoke, string text);

private void updateFormObjectType(FormObjectType objectWithoutInvoke, string text)
{
    MainForm.Invoke(new updateMainFormObject(UpdateObject), objectWithoutInvoke, text);
}

public void UpdateObject(ToolStripStatusLabel objectWithoutInvoke, string text)
{
    objectWithoutInvoke.Text = text;
}

它的工作原理与上面相同，但如果您没有带有 invokerequired 的对象，但可以访问 MainForm，则它是一种不同的方法

score 5 · Accepted Answer

例如从 UI 线程的 Control 中获取文本：

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

score 5 · Accepted Answer

与先前的答案相同，但添加了一个非常简短的内容，允许使用所有 Control 属性而不会出现跨线程调用异常。

辅助方法

/// <summary>
/// Helper method to determin if invoke required, if so will rerun method on correct thread.
/// if not do nothing.
/// </summary>
/// <param name="c">Control that might require invoking</param>
/// <param name="a">action to preform on control thread if so.</param>
/// <returns>true if invoke required</returns>
public bool ControlInvokeRequired(Control c, Action a)
{
    if (c.InvokeRequired) c.Invoke(new MethodInvoker(delegate
    {
        a();
    }));
    else return false;

    return true;
}

示例使用

// usage on textbox
public void UpdateTextBox1(String text)
{
    //Check if invoke requied if so return - as i will be recalled in correct thread
    if (ControlInvokeRequired(textBox1, () => UpdateTextBox1(text))) return;
    textBox1.Text = ellapsed;
}

//Or any control
public void UpdateControl(Color c, String s)
{
    //Check if invoke requied if so return - as i will be recalled in correct thread
    if (ControlInvokeRequired(myControl, () => UpdateControl(c, s))) return;
    myControl.Text = s;
    myControl.BackColor = c;
}

score 5 · Accepted Answer

this.Invoke(new MethodInvoker(delegate
            {
                //your code here;
            }));

score 5 · Accepted Answer

解决此问题的简单且可重复使用的方法。

扩展方法

public static class FormExts
{
    public static void LoadOnUI(this Form frm, Action action)
    {
        if (frm.InvokeRequired) frm.Invoke(action);
        else action.Invoke();
    }
}

示例使用

private void OnAnyEvent(object sender, EventArgs args)
{
    this.LoadOnUI(() =>
    {
        label1.Text = "";
        button1.Text = "";
    });
}

score 3 · Accepted Answer

同样的问题：how-to-update-the-gui-from-another-thread-in-c

两种方式：

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

score 2 · Accepted Answer

只需使用这个：

this.Invoke((MethodInvoker)delegate
            {
                YourControl.Property= value; // runs thread safe
            });

score 0 · Accepted Answer

0

行动 y; //在类中声明

label1.Invoke(y=()=>label1.Text="text");

于 2017-12-17T06:40:25.737 回答

score 0 · Accepted Answer

我知道我迟到了，但我想有一个简单的解决方案可以解决这个问题。可能，这对其他人有帮助。

您可以编写:CheckforIllegalCrossThreadCalls并将其值设置为False. 您需要在主页的构造函数中编写它。

参考这个：

score -3 · Accepted Answer

跨线程操作有两种选择。

Control.InvokeRequired Property

第二个是使用

SynchronizationContext Post Method

Control.InvokeRequired 仅在从 Control 类继承的工作控件时有用，而 SynchronizationContext 可以在任何地方使用。一些有用的信息如下链接

跨线程更新 UI | 。网

使用 SynchronizationContext 的跨线程更新 UI | 。网

c# - 跨线程操作无效：控件从创建它的线程以外的线程访问

23 回答 23

UI中的线程模型

用户界面线程

BeginInvoke 和 Invoke 方法

调用

开始调用

代码解决方案

Related

Reference