为什么编译器不能确定这个 lambda 是一个委托？

Question

考虑一下这个小程序。

public class Program
{
    public static void Main()
    {
        // the first path compiles
        RunAction(() => { });

        // the second path does not compile
        RunDelegate(() => {});
    }

    private static void RunAction(Action run) => RunDelegate(run);
    private static void RunDelegate(Delegate run) { }
}

第一个路径编译并暗示

1. () => {} lambda 是一个Action，
2. Action 是Delegate，并且
3. 因此() => {} lambda 是Delegate。

为什么第二个路径不编译？

通常编译器能够在步骤 (1) 和 (3) 之间进行跳跃。这是编译器通常如何处理这种嵌套的 is-a 关系的示例。

public class Program2
{
    public static void Main()
    {
        // both of these comple
        AcceptPerson(new Programmer());
        AcceptAnimal(new Programmer());
    }

    private static void AcceptPerson(Person p) => AcceptAnimal(p);
    private static void AcceptAnimal(Animal a) { }
}

public class Programmer : Person { }
public class Person : Animal { }
public class Animal { }

Answer 1

() => { } 等匿名函数没有“默认”委托类型。这样的表达式可以隐式转换为 any 正确签名和返回类型的具体委托类型（受各种自然变化规则的约束）。

您可以有许多匹配的委托类型：

namespace TestFramework
{
  public delegate void TestDelegate();
}

namespace System
{
  public delegate void Action();
}

namespace System.Threading
{
  public delegate void ThreadStart();
}

...

在所有这些可能的具体委托类型中（每个都作为抽象 System.Delegate 作为其（间接）基类）没有首选的一个。

从表达式() => { } 到每个表达式都有一个隐式转换：

TestDelegate f = () => { };
Action g = () => { };
ThreadStart h = () => { };
...

由于隐式转换，您的调用 RunAction(() => { }); 有效。

但是对于RunDelegate(() => {});，不知道要使用什么具体的委托类型。您必须执行以下操作之一：

RunDelegate((TestDelegate)(() => { }));
RunDelegate((Action)(() => { }));
RunDelegate((ThreadStart)(() => { }));
...

你的问题的cmets是正确的。

与此相关的是它不会编译：

var f = () => { };  // illegal, shows that '() => { }' does NOT have type System.Action

你不能使用像myBool ? (() => { }) : null这样的子表达式，等等。