清理散落着InvokeRequired的代码

那么这个呢:

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 });
}

打电话 Invoke 来自UI线程的效率有点低。

相反,您可以创建 InvokeIfNeeded 采用 Action 参数。(这也允许您删除 new Action(...) 来自callsite)

我一直在反复阅读关于添加逻辑检查的参数,以确定调用是否应该在不在UI线程上、也不在UI线程本身上时使用IFF。我写了一个检查执行时间的类(via 秒表 )对一种方法的效率进行粗略估计。

结果可能会让你们中的一些人感到惊讶(这些测试是通过 显示的窗体 事件):

     // 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线程(通过 调用() )有利于大大提高效率。

我意识到 one answer that's pretty much spot on ,但我想也发布我的看法(我也发布了 here ).

我的有点不同,因为它可以稍微更安全地处理空控件,并在必要时返回结果。当我试图调用在可能为空的父窗体上显示MessageBox并返回显示该MessageBox的对话框结果时,这两种方法都很有用。

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));

我不相信 Control.Invoke 是更新用户界面的最佳选择。我不能肯定你的情况,因为我不知道在什么情况下 UpdateSummary 在召唤中。但是,如果定期调用它作为显示进度信息的机制(这是我从代码片段中得到的印象),那么 通常 更好的选择。这个选项是让UI线程轮询状态,而不是让工作线程推送它。

在这种情况下,应考虑投票方法的原因是:

• 它打破了UI和工作线程之间的紧密耦合 控件调用 强加。
• 它把更新UI线程的责任放在UI线程上,不管它应该属于哪里。
• UI线程可以指定更新的时间和频率。
• 不存在UI消息泵被溢出的风险,就像由工作线程启动的封送处理技术一样。
• 在继续下一步之前,工作线程不必等待更新已执行的确认(即,您可以在UI和工作线程上获得更多的吞吐量)。

所以考虑创建一个 System.Windows.Forms.Timer 定期检查文本是否显示在 Control 而不是从工作线程启动推送。再说一遍,在不知道你具体要求的情况下,我不愿意说这绝对是你需要走的方向,但是 最 很多情况下 是 比 控件调用 选择。

显然,这种方法消除了 InvokedRequired 完全检查。不管怎样,它简化了 全部的 UI/工作线程交互的其他方面。

对于纯视图控件,我首选的方法是将所有控件状态封装在一个类中,该类可以在不经历任何不一致状态的情况下进行更新(一个简单的方法是将需要更新的所有内容放在一个不可变的类中,并在需要更新时创建类的新实例)。然后有一个方法联锁交换updateNeeded标志,如果没有挂起的更新,但IsHandleCreated为true,则开始调用更新过程。在进行任何更新之前,更新过程应首先清除updateNeeded标志(如果有人试图在此时更新控件,则将开始另一个请求)。注意,如果控件在准备更新时被释放,则必须准备捕获并吞咽异常(我认为是非法操作)。

顺便说一下,如果一个控件还没有连接到一个线程(通过添加到一个可见窗口,或者让它所在的窗口变得可见),直接更新它是合法的,但对它使用BeginInvoke或Invoke是不合法的。

我还不能发表评论,希望有人能看到这一点,并将其添加到接受的答案,否则是当场。

control.Invoke(new Action(() => action(control))); 应该读
control.Invoke(new Action(() => action(control)), null);

如书面所述,接受的答案不会编译,因为 ISynchronizeInvoke.Invoke() 不具有只有一个参数的重载,如 Control.Invoke() 做。

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

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