清理乱七八糟的代码 InvokeRequired [重复]

Question

我知道，当从任何非 UI 线程操作 UI 控件时，您必须将调用编组到 UI 线程以避免出现问题。普遍的共识是您应该使用 test InvokeRequired，如果为真，请使用 .Invoke 执行封送处理。

这导致很多代码看起来像这样：

private void UpdateSummary(string text)
{
    if (this.InvokeRequired)
    {
        this.Invoke(new Action(() => UpdateSummary(text)));
    }
    else
    {
        summary.Text = text;
    }
}

我的问题是：我可以省略 InvokeRequired 测试而只调用 Invoke，如下所示：

private void UpdateSummary(string text)
{
    this.Invoke(new Action(() => summary.Text = text));
}

这样做有问题吗？如果是这样，是否有更好的方法来保留 InvokeRequired 测试，而不必到处复制和粘贴此模式？

Answer 1

这个怎么样：

public static class ControlHelpers
{
    public static void InvokeIfRequired<T>(this T control, Action<T> action) where T : ISynchronizeInvoke
    {
        if (control.InvokeRequired)
        {
            control.Invoke(new Action(() => action(control)), null);
        }
        else
        {
            action(control);
        }
    }
}

像这样使用它：

private void UpdateSummary(string text)
{
    summary.InvokeIfRequired(s => { s.Text = text });
}

Answer 2

从 UI 线程调用 Invoke 效率有点低。

相反，您可以创建一个采用Action 参数的InvokeIfNeeded 扩展方法。 （这也将允许您从调用站点中删除 new Action(...)）

Answer 3

我一直在阅读有关添加逻辑检查的参数，以确定在不在 UI 线程上而不是在 UI 线程本身上时是否应该使用调用 IFF。我编写了一个类来检查各种方法的执行时间（通过秒表），以粗略估计一种方法相对于另一种方法的效率。

结果可能会让你们中的一些人感到惊讶（这些测试是通过 Form.Shown 事件运行的）：

     // notice that we are updating the form's title bar 10,000 times
     // directly on the UI thread
     TimedAction.Go
     (
        "Direct on UI Thread",
        () =>
        {
           for (int i = 0; i < 10000; i++)
           {
              this.Text = "1234567890";
           }
        }
     );

     // notice that we are invoking the update of the title bar
     // (UI thread -> [invoke] -> UI thread)
     TimedAction.Go
     (
        "Invoke on UI Thread",
        () =>
        {
           this.Invoke
           (
              new Action
              (
                 () =>
                 {
                    for (int i = 0; i < 10000; i++)
                    {
                       this.Text = "1234567890";
                    }
                 }
              )
           );
        }
     );

     // the following is invoking each UPDATE on the UI thread from the UI thread
     // (10,000 invokes)
     TimedAction.Go
     (
        "Separate Invoke on UI Thread",
        () =>
        {
           for (int i = 0; i < 10000; i++)
           {
              this.Invoke
              (
                 new Action
                 (
                    () =>
                    {
                       this.Text = "1234567890";
                    }
                 )
              );
           }
        }
     );

结果如下：

• TimedAction::Go()+0 - 调试：[DEBUG] 秒表 [直接在 UI 线程上]：300 毫秒
• TimedAction::Go()+0 - 调试：[DEBUG] 秒表 [在 UI 线程上调用]：299 毫秒
• TimedAction::Go()+0 - 调试：[DEBUG] 秒表 [在 UI 线程上单独调用]：649 毫秒

我的结论是，无论您是在 UI 线程还是工作线程上，您都可以随时安全地调用，而无需通过消息泵循环返回的大量开销。但是，在 UI 线程上执行大部分工作而不是对 UI 线程进行多次调用（通过 Invoke()）是有利的，并且大大提高了效率。

Answer 4

我意识到已经有 one answer that's pretty much spot on，但我也想发布我对它的看法（我也发布了 here）。

我的有点不同，它可以稍微更安全地处理空控件，并且可以在必要时返回结果。当我尝试调用在可能为 null 的父窗体上显示 MessageBox 并返回显示该 MessageBox 的 DialogResult 时，这两种方法都派上了用场。

---

using System;
using System.Windows.Forms;

/// <summary>
/// Extension methods acting on Control objects.
/// </summary>
internal static class ControlExtensionMethods
{
    /// <summary>
    /// Invokes the given action on the given control's UI thread, if invocation is needed.
    /// </summary>
    /// <param name="control">Control on whose UI thread to possibly invoke.</param>
    /// <param name="action">Action to be invoked on the given control.</param>
    public static void MaybeInvoke(this Control control, Action action)
    {
        if (control != null && control.InvokeRequired)
        {
            control.Invoke(action);
        }
        else
        {
            action();
        }
    }

    /// <summary>
    /// Maybe Invoke a Func that returns a value.
    /// </summary>
    /// <typeparam name="T">Return type of func.</typeparam>
    /// <param name="control">Control on which to maybe invoke.</param>
    /// <param name="func">Function returning a value, to invoke.</param>
    /// <returns>The result of the call to func.</returns>
    public static T MaybeInvoke<T>(this Control control, Func<T> func)
    {
        if (control != null && control.InvokeRequired)
        {
            return (T)(control.Invoke(func));
        }
        else
        {
            return func();
        }
    }
}

用法：

myForm.MaybeInvoke(() => this.Text = "Hello world");

// Sometimes the control might be null, but that's okay.
var dialogResult = this.Parent.MaybeInvoke(() => MessageBox.Show(this, "Yes or no?", "Choice", MessageBoxButtons.YesNo));

Answer 5

对于仅查看控件，我首选的方法是将所有控件状态封装在一个类中，该类可以在不经历任何不一致状态的情况下进行更新（一种简单的方法是将所有需要的东西一起更新为一个不可变的类，并在需要更新时创建该类的新实例）。然后有一个方法，它将 Interlocked.Exchange 一个 updateNeeded 标志，如果没有更新挂起但 IsHandleCreated 为真，则 BeginInvoke 更新过程。更新过程应该清除 updateNeeded 标志作为它做的第一件事，在做任何更新之前（如果有人试图在此时更新控件，另一个请求将被 BeginInvoked）。请注意，如果控件在您准备更新时被释放，您必须准备好捕获并吞下异常（我认为是 IllegalOperation）。

顺便说一句，如果控件尚未加入线程（通过添加到可见窗口，或使其所在的窗口变为可见），直接更新它是合法的，但使用 BeginInvoke 或 Invoke 是不合法的就可以了。

Answer 6

我不相信Control.Invoke 是更新 UI 的最佳选择。在你的情况下，我不能肯定地说，因为我不知道UpdateSummary 在什么情况下被调用。但是，如果您定期调用它作为显示进度信息的机制（这是我从代码 sn-p 中得到的印象），那么通常会有更好的选择。该选项是让 UI 线程轮询状态，而不是让工作线程推送它。

在这种情况下应该考虑轮询方式的原因是：

• 它打破了Control.Invoke 强加的 UI 和工作线程之间的紧密耦合。
• 它将更新 UI 线程的责任放在它本来应该属于的 UI 线程上。
• UI 线程可以决定更新的时间和频率。
• 不存在 UI 消息泵溢出的风险，就像工作线程启动的封送处理技术那样。
• 工作线程无需等待确认更新已执行，即可继续执行后续步骤（即，您可以在 UI 和工作线程上获得更高的吞吐量）。

因此考虑创建一个System.Windows.Forms.Timer，它定期检查要在Control 上显示的文本，而不是从工作线程启动推送。同样，在不知道您的确切要求的情况下，我不愿意明确地说这是您需要走的方向，但在 大多数 很多情况下，它 比 Control.Invoke 选项更好.

显然，这种方法完全消除了InvokedRequired 检查的必要性。没关系，它简化了 UI/工作线程交互的所有其他方面。

Answer 7

我还不能发表评论，希望有人会看到这个并将其添加到已接受的答案中，否则就会出现。

control.Invoke(new Action(() => action(control))); 应改为
control.Invoke(new Action(() => action(control)), null);

正如所写，接受的答案不会编译，因为 ISynchronizeInvoke.Invoke() 没有像 Control.Invoke() 这样只有 1 个参数的重载。

另一件事是，用法可能更清楚
summary.InvokeIfRequired(c => { summary.Text = text; });，而不是书面 summary.InvokeIfRequired(c => { textBox.Text = text });

Answer 8

如果可能的话，使用 BackgroudWorker 来使 UI 响应并使用 ReportProgress 更新 UI 会更容易，因为它与 UI 运行在同一线程上，因此您不需要 InvokeRequired。