为什么委托实例不总是被缓存？

Question

在这种情况下，为什么 C# 编译器不创建缓存委托实例的代码Action(SomeMethod)：

void MyMethod() {
   Decorator(SomeMethod);
}

void Decorator(Action a) { a(); }
void SomeMethod() { }

它仅在SomeMethod静态时才执行此操作：

static void SomeMethod() { }

编辑：

为了更清楚，我们看下面的代码：

class A {
    public void M1() {
       var b = new B();
       b.Decorate(M2);
    }

    public void M2() {
    }
}


class B {
    public void Decorate(Action a) {
        Console.WriteLine("Calling");
        a();
    }
}

如果你想避免每次调用 M1 时进行委托分配，你可以轻松做到，但它非常难看：

using System;

class A {
    Action _m2;

    public A() {
        _m2 = new Action(M2);
    }

    public void M1() {
       var b = new B();
       b.Decorate(_m2);
    }

     public void M2() {
     }
}


class B {
    public void Decorate(Action a) {
        Console.WriteLine("Calling");
        a();
    }
}

所以我的问题是，编译器无法生成类似代码的原因是什么？我看不到任何副作用。

我并不是说没有理由，从事编译器工作的人可能比我聪明得多。我只是想了解在哪些情况下这不起作用。

Answer 1

它无法为实例方法缓存它，因为目标实例是delegate 的一部分，并且它确实想使用静态字段进行缓存。不捕获任何变量等的静态方法调用可以非常便宜地进行缓存，但是当涉及状态并计为状态时，它会变得更加复杂this。

是的，我想可以使用实例字段来缓存() => this.SomeMethod()，但坦率地说，this成为目标是一种相对罕见的情况，并且不能解决一般问题。

然而，它也只对lambda语法执行此操作，即即使SomeMethod是static

Decorator(SomeMethod); // not cached
Decorator(() => SomeMethod()); // cached

你可以在这里看到差异

这是因为差异是可以检测到的（不同的对象引用与相同的对象引用），并且理论上可能会导致使用原始（非 lambda）语法的现有代码中的不同程序行为；因此，缓存规定迄今为止尚未应用于旧语法。兼容性原因。不过，这个问题已经讨论多年了；在我看来，这是像 L 值捕获的改变这样的事情之一foreach，它可能会被改变，而不会像我们想象的那样破坏世界。

要查看基于已编辑问题的示例中的理论差异：

using System;

class A
{
    static void Main()
    {
        var obj = new A();
        Console.WriteLine("With cache...");
        for (int i = 0; i < 5; i++) obj.WithCache();
        Console.WriteLine("And without cache...");
        for (int i = 0; i < 5; i++) obj.WithoutCache();
    }
    Action _m2;
    B b = new B();
    public void WithCache() => b.Decorate(_m2 ??= M2);
    public void WithoutCache() => b.Decorate(M2);
    public void M2() => Console.WriteLine("I'm M2");
}

 class B
{
    private object _last;
    public void Decorate(Action a)
    {
        if (_last != (object)a)
        {
            a();
            _last = a;
        }
        else
        {
            Console.WriteLine("No do-overs!");
        }
    }
}

当前输出：

With cache...
I'm M2
No do-overs!
No do-overs!
No do-overs!
No do-overs!
And without cache...
I'm M2
I'm M2
I'm M2
I'm M2
I'm M2