为什么 lambda 表达式作为普通委托参数提供时必须进行强制转换

Question

采用方法 System.Windows.Forms.Control.Invoke(Delegate method)

为什么这会产生编译时错误：

string str = "woop";
Invoke(() => this.Text = str);
// Error: Cannot convert lambda expression to type 'System.Delegate'
// because it is not a delegate type

然而这工作正常：

string str = "woop";
Invoke((Action)(() => this.Text = str));

当方法需要一个普通的委托时？

Answer 1

聚会有点晚了，但你也可以像这样投射

this.BeginInvoke((Action)delegate {
    // do awesome stuff
});

Answer 2

 this.Dispatcher.Invoke((Action)(() => { textBox1.Text = "Test 123"; }));

Answer 3

使用 XUnit 和 Fluent Assertions 可以以我认为非常酷的方式使用此内联功能。

之前

[Fact]
public void Pass_Open_Connection_Without_Provider()
{
    Action action = () => {
        using (var c = DbProviderFactories.GetFactory("MySql.Data.MySqlClient").CreateConnection())
        {
            c.ConnectionString = "<xxx>";
            c.Open();
        }
    };

    action.Should().Throw<Exception>().WithMessage("xxx");
}

之后

[Fact]
public void Pass_Open_Connection_Without_Provider()
{
    ((Action)(() => {
        using (var c = DbProviderFactories.GetFactory("<provider>").CreateConnection())
        {
            c.ConnectionString = "<connection>";
            c.Open();
        }
    })).Should().Throw<Exception>().WithMessage("Unable to find the requested .Net Framework Data Provider.  It may not be installed.");
}

Answer 4

其他答案在编写时是正确的，但从 C# 10.0（从 2021 年起）开始，编译器可以推断出合适的委托类型（例如某些 Func<...>< /code>、Action<...> 或生成的委托类型）在这种情况下。

请参阅 C# 10 功能 - Lambda改进。

string str = "woop";
Invoke(() => this.Text = str);   // OK in C# 10.0, in this case 'Func<string>' is picked

string str = "woop";
Invoke(() => { this.Text = str; });   // OK in C# 10.0, in this case 'Action' is picked

注释假定签名 Invoke(Delegate method) 如您的问题中所示。 当然，如果该方法需要特定的（非抽象）委托类型，C# 将尝试将 lambda 转换为该类型，C# 10.0 之前的情况也是如此。

Answer 5

lambda 表达式可以转换为委托类型或表达式树 - 但它必须知道哪种委托类型。 仅仅知道签名是不够的。 例如，假设我有：

public delegate void Action1();
public delegate void Action2();

...

Delegate x = () => Console.WriteLine("hi");

您期望 x 引用的对象的具体类型是什么？ 是的，编译器可以生成具有适当签名的新委托类型，但这很少有用，而且您最终进行错误检查的机会也更少。

如果您想轻松地使用 Action 调用 Control.Invoke，最简单的方法就是向 Control 添加扩展方法：

public static void Invoke(this Control control, Action action)
{
    control.Invoke((Delegate) action);
}

Answer 6

厌倦了一遍又一遍地转换 lambda？

public sealed class Lambda<T>
{
    public static Func<T, T> Cast = x => x;
}

public class Example
{
    public void Run()
    {
        // Declare
        var c = Lambda<Func<int, string>>.Cast;
        // Use
        var f1 = c(x => x.ToString());
        var f2 = c(x => "Hello!");
        var f3 = c(x => (x + x).ToString());
    }
}

Answer 7

十分之九的情况下，人们会遇到这种情况，因为他们正在尝试编组到 UI 线程。 这是一种懒惰的方法：

static void UI(Action action) 
{ 
  System.Windows.Threading.Dispatcher.CurrentDispatcher.BeginInvoke(action); 
}

现在它已经被输入了，问题就消失了（qv Skeet 的回答），我们有这个非常简洁的语法：

int foo = 5;
public void SomeMethod()
{
  var bar = "a string";
  UI(() =>
  {
    //lifting is marvellous, anything in scope where the lambda
    //expression is defined is available to the asynch code
    someTextBlock.Text = string.Format("{0} = {1}", foo, bar);        
  });
}

对于奖励点，这里有另一个提示。 您不会对 UI 内容执行此操作，但在需要 SomeMethod 阻止直到其完成的情况下（例如请求/响应 I/O，等待响应），请使用 WaitHandle（qv msdn WaitAll、WaitAny、WaitOne）。

请注意，AutoResetEvent 是 WaitHandle 的派生物。

public void BlockingMethod()
{
  AutoResetEvent are = new AutoResetEvent(false);
  ThreadPool.QueueUserWorkItem ((state) =>
  {
    //do asynch stuff        
    are.Set();
  });      
  are.WaitOne(); //don't exit till asynch stuff finishes
}

最后一个提示是因为事情可能会变得混乱：WaitHandles 会阻止线程。 这就是他们应该做的。 如果您在 UI 线程停止时尝试封送至 UI 线程，您的应用程序将挂起。 在这种情况下，（a）需要进行一些认真的重构，（b）作为临时黑客，您可以像这样等待：

  bool wait = true;
  ThreadPool.QueueUserWorkItem ((state) =>
  {
    //do asynch stuff        
    wait = false;
  });
  while (wait) Thread.Sleep(100);

Answer 8

彼得·沃恩. 你是个大男人。
进一步阐述你的概念，我想出了这两个函数。

private void UIA(Action action) {this.Invoke(action);}
private T UIF<T>(Func<T> func) {return (T)this.Invoke(func);}

我将这两个函数放入我的表单应用程序中，我可以像这样从后台工作人员进行调用

int row = 5;
string ip = UIF<string>(() => this.GetIp(row));
bool r = GoPingIt(ip);
UIA(() => this.SetPing(i, r));

也许有点懒，但我不必设置工作人员完成的功能，
在这种情况下，它非常方便。

private void Ping_DoWork(object sender, System.ComponentModel.DoWorkEventArgs e)
{
  int count = this.dg.Rows.Count;
  System.Threading.Tasks.Parallel.For(0, count, i => 
  {
    string ip = UIF<string>(() => this.GetIp(i));
    bool r = GoPingIt(ip);
    UIA(() => this.SetPing(i, r));
  });
  UIA(() => SetAllControlsEnabled(true));
}

本质上，从 gui DataGridView 获取一些 IP 地址，对它们执行 ping 操作，将生成的图标设置为绿色或红色，然后重新启用表单上的按钮。 是的，它是后台工作者中的“parallel.for”。 是的，这是大量的调用开销，但对于短列表和更紧凑的代码来说，它可以忽略不计。

Answer 9

我尝试根据 @Andrey Naumov 的答案构建此内容。 也许这是一个小小的改进。

public sealed class Lambda<S>
{
    public static Func<S, T> CreateFunc<T>(Func<S, T> func)
    {
        return func;
    }

    public static Expression<Func<S, T>> CreateExpression<T>(Expression<Func<S, T>> expression)
    {
        return expression;
    }

    public Func<S, T> Func<T>(Func<S, T> func)
    {
        return func;
    }

    public Expression<Func<S, T>> Expression<T>(Expression<Func<S, T>> expression)
    {
        return expression;
    }
}

其中类型参数 S 是形式参数（输入参数，推断其余类型所需的最低参数）。 现在您可以这样调用它：

var l = new Lambda<int>();
var d1 = l.Func(x => x.ToString());
var e1 = l.Expression(x => "Hello!");
var d2 = l.Func(x => x + x);

//or if you have only one lambda, consider a static overload
var e2 = Lambda<int>.CreateExpression(x => "Hello!");

您可以在同一个类中类似地为 Action 和 Expression> 提供额外的重载。 对于其他内置委托和表达式类型，您必须编写单独的类，例如 Lambda、Lambda、 Lambda 等。

与原始方法相比，我认为这样做的优点是：

1. 少了一个类型规范（仅需要指定形式参数）。

2. 这让您可以自由地将它用于任何 Func，而不仅仅是当 T 是 string 时，如示例所示。

3. 立即支持表达式。 在之前的方法中，您必须再次指定类型，例如：

   var e = Lambda<表达式>>.Cast(x => "Hello!"); 
   
     //或者如果“Cast”是非泛型“Lambda”类的实例成员： 
     var e = lambda.Cast<表达式>>(x => "Hello!"); 
     

   用于表达式。

4. 为其他委托（和表达式）类型扩展类与上面类似很麻烦。

   var e = Lambda>.Cast(x => x.ToString()); 
   
     //或者对于表达式>   如果“Cast”是非泛型“Lambda”类的实例成员： 
     var e = lambda.Cast<表达式>>(x => x.ToString()); 
     

在我的方法中，您只需声明类型一次（对于 Func 来说也少声明一次）。

---

实现安德烈的答案的另一种方法是不完全通用，

public sealed class Lambda<T>
{
    public static Func<Func<T, object>, Func<T, object>> Func = x => x;
    public static Func<Expression<Func<T, object>>, Expression<Func<T, object>>> Expression = x => x;
}

所以事情会减少到：

var l = Lambda<int>.Expression;
var e1 = l(x => x.ToString());
var e2 = l(x => "Hello!");
var e3 = l(x => x + x);

这甚至更少的打字，但你失去了一定的类型安全性，我认为，这是不值得的。