Control.BeginInvoke 的 MethodInvoker 与 Action

Question

哪个更正确，为什么？

Control.BeginInvoke(new Action(DoSomething), null);

private void DoSomething()
{
    MessageBox.Show("What a great post");
}

或者

Control.BeginInvoke((MethodInvoker) delegate { 
    MessageBox.Show("What a great post");
}); 

我感觉我在做同样的事情，所以什么时候是使用 MethodInvoker 与 Action 的正确时机，甚至是编写 lambda 表达式？

编辑：我知道编写 lambda 与 Action 之间并没有太大区别，但 MethodInvoker 似乎是为特定用途。 它有什么不同吗？

Answer 1

两者都同样正确，但 Control.Invoke 的文档 指出：

委托可以是一个实例
EventHandler，在这种情况下是发送者
参数将包含此控件，
并且事件参数将包含
EventArgs.Empty。 代表还可以
是 MethodInvoker 的实例，或者
任何其他代表作废
参数列表。 致电
EventHandler 或 MethodInvoker 委托
比调用另一个更快
委托类型。

所以 MethodInvoker 将是一个更有效的选择。

Answer 2

对于下面的每个解决方案，我运行 131072 (128*1024) 次迭代（在一个单独的线程中）。
VS2010 性能助手给出以下结果：

• 只读 MethodInvoker：5664.53 (+0%)
• 新 MethodInvoker：5828.31 (+2.89%)
• MethodInvoker 中的函数转换：5857.07 (+3.40%)
• 只读操作：6467.33 (+14.17%)
• 新操作：6829.07 (+20.56%)

在每次迭代时调用新的 Action

    private void SetVisibleByNewAction()
    {
        if (InvokeRequired)
        {
            Invoke(new Action(SetVisibleByNewAction));
        }
        else
        {
            Visible = true;
        }
    }

调用只读的内置构造函数，在每次迭代时Action

    // private readonly Action _actionSetVisibleByAction
    // _actionSetVisibleByAction= SetVisibleByAction;
    private void SetVisibleByAction()
    {
        if (InvokeRequired)
        {
            Invoke(_actionSetVisibleByAction);
        }
        else
        {
            Visible = true;
        }
    }

调用新的操作每次迭代时的MethodInvoker。

    private void SetVisibleByNewMethodInvoker()
    {
        if (InvokeRequired)
        {
            Invoke(new MethodInvoker(SetVisibleByNewMethodInvoker));
        }
        else
        {
            Visible = true;
        }
    }

在每次迭代时调用只读内置构造函数 MethodInvoker 在每次迭代时

    // private readonly MethodInvoker _methodInvokerSetVisibleByMethodInvoker 
    // _methodInvokerSetVisibleByMethodInvoker = SetVisibleByMethodInvoker;
    private void SetVisibleByMethodInvoker()
    {
        if (InvokeRequired)
        {
            Invoke(_methodInvokerSetVisibleByMethodInvoker);
        }
        else
        {
            Visible = true;
        }
    }

调用 MethodInvoker 中的函数转换

    private void SetVisibleByDelegate()
    {
        if (InvokeRequired)
        {
            Invoke((MethodInvoker) SetVisibleByDelegate);
        }
        else
        {
            Visible = true;
        }
    }

“新操作”解决方案的调用示例：

    private void ButtonNewActionOnClick(object sender, EventArgs e)
    {
        new Thread(TestNewAction).Start();
    }

    private void TestNewAction()
    {
        var watch = Stopwatch.StartNew();
        for (var i = 0; i < COUNT; i++)
        {
            SetVisibleByNewAction();
        }
        watch.Stop();
        Append("New Action: " + watch.ElapsedMilliseconds + "ms");
    }

Answer 3

我更喜欢使用 lambda 和 Actions/Funcs：

Control.BeginInvoke(new Action(() => MessageBox.Show("What a great post")));

Answer 4

Action 是在 System 中定义的，而 MethodInvoker 是在 System.Windows.Forms 中定义的 - 您最好使用 Action，因为它可以移植到其他地方。 您还会发现比 MethodInvoker 接受 Action 作为参数的地方更多。

但是，文档确实表明在 Control.Invoke() 中调用 EventHandler 或 MethodInvoker 类型的委托将比任何其他类型更快。

除了它们所在的命名空间之外，我不认为 Action 和 MethodInvoker 之间存在有意义的功能差异 - 它们本质上都定义为：

public delegate void NoParamMethod();

顺便说一句，Action 有几个重载，允许参数被传入 - 并且它是通用的，因此它们可以是类型安全的。

Answer 5

另外，根据 MSDN：

MethodInvoker 提供了一个简单的委托，用于调用带有 void 参数列表的方法。 当调用控件的 Invoke 方法时，或者当您需要一个简单的委托但不想自己定义一个委托时，可以使用此委托。

另一方面，操作最多可以使用 4 个参数。

但我认为 MethodInvoker 和 Action 之间没有任何区别，因为它们都只是封装了一个不接受参数并返回 void 的委托。 。

如果你看看他们的定义，你就会明白这一点

public delegate void MethodInvoker();
public delegate void Action();

顺便说一句，你也可以将第二行写为。

Control.BeginInvoke(new MethodInvoker(DoSomething), null);

Answer 6

在大多数情况下，这只是一个偏好问题，除非您打算重用 DoSomething() 方法。 此外，匿名函数会将作用域变量放置在堆上，可能会使其成为更昂贵的函数。

Answer 7

不要忘记以某种方式检查当前控件是否可用，以避免关闭表单时出现错误。

if(control.IsHandleCreated)
control.BeginInvoke((MethodInvoker)(() => control.Text="check123"));