Use a cached delegate for method group conversion

[gafter]

The method group conversion today always creates a fresh delegate instance.

Instead, for a method group conversion from a static method we should cache it and only create it once, like we do for non-capturing lambda expressions.

[The C# language spec is being modified to permit this]

[stephentoub]

WOO HOO!!!

[danieljohnson2]

Isn't this a breaking change? I don't think I've ever written code that cares about delegate identity (as opposed to equality), but if it anybody has, this could break it.

Also, it used to be that you got crazy compiler magic if you used the delegate { ... } or foo => bar syntaxes, and heaven knows what code gets generated then (caching the delegate is the least of it) But the magic happens only if you ask for it.

Now, the rule is to be that the crazy compiler magic happens unless you say new. Admittedly, the 'magic' here is really just injecting a small, bounded memory leak, but I think it's still surprising. I was surprised when I found out that => does this sometimes, and I knew about Expression<T> already, which is far crazier.

I guess this is mostly harmless, so long as you do not also break the equality semantics of the delegates produced, and so long as you can turn this off with the new EventHandler(...) syntax.

[mburbea]

Yes please. Can we do something about delegates in generic methods? Currently they are still a much slower caching (if they get cached at all) strategy then for delegates created in non-generic methods

[Lukazoid]

👍 for this, also as per the comment by @mburbea is there any interest in caching for delegates in generic methods? Is it worth creating a separate issue for it.

[stephentoub]

is there any interest in caching for delegates in generic methods? Is it worth creating a separate issue for it.

Roslyn already does this. For example, with this code:

using System;

public class Test
{
    public static void Main() { GenericMethod<string>(); }

    private static void GenericMethod<T>()
    {
        InvokeAction(() => Console.WriteLine(typeof(T)));
    }

    private static void InvokeAction(Action action)
    {
        action();
    }
}

the code generated for GenericMethod<T> looks like this:

private static void GenericMethod<T>()
{
    InvokeAction(
        <>c__1<T>.<>9__1_0 ?? 
        (<>c__1<T>.<>9__1_0 = new Action(<>c__1<T>.<>9.<GenericMethod>b__1_0)));
}

private sealed class <>c__1<T>
{
    public static readonly Test.<>c__1<T> <>9;
    public static Action <>9__1_0;
    internal void <GenericMethod>b__1_0();
    ...
}

[Lukazoid]

Oh sweet, I did verify the IL but forgot I wasn't using Roslyn yet at work!

[sharwell]

So what you're saying is the compiler should handle the insanity that was DotNetAnalyzers/StyleCopAnalyzers#1689?

I'm totally in agreement there. 👍