Cambios en el comportamiento del almacenamiento en caché de delegados en Roslyn

Dado el siguiente código:

public class C
{
    public void M()
    {
        var x = 5;
        Action<int> action = y => Console.WriteLine(y);
    }
}

Usando VS2013,. NET 4.5. Al mirar el código descompilado, podemos ver que el compilador está almacenando en caché el delegado en el sitio de la llamada:

public class C
{
    [CompilerGenerated]
    private static Action<int> CS$<>9__CachedAnonymousMethodDelegate1;
    public void M()
    {
        if (C.CS$<>9__CachedAnonymousMethodDelegate1 == null)
        {
            C.CS$<>9__CachedAnonymousMethodDelegate1 = new Action<int>(C.<M>b__0);
        }
        Action<int> arg_1D_0 = C.CS$<>9__CachedAnonymousMethodDelegate1;
    }
    [CompilerGenerated]
    private static void <M>b__0(int y)
    {
        Console.WriteLine(y);
    }
}

Mirando el mismo código descompilado en Roslyn (usando TryRoslyn ), se obtiene la siguiente salida:

public class C
{
    [CompilerGenerated]
    private sealed class <>c__DisplayClass0
    {
        public static readonly C.<>c__DisplayClass0 CS$<>9__inst;
        public static Action<int> CS$<>9__CachedAnonymousMethodDelegate2;
        static <>c__DisplayClass0()
        {
            // Note: this type is marked as 'beforefieldinit'.
            C.<>c__DisplayClass0.CS$<>9__inst = new C.<>c__DisplayClass0();
        }
        internal void <M>b__1(int y)
        {
            Console.WriteLine(y);
        }
    }
    public void M()
    {
        Action<int> arg_22_0;
        if (arg_22_0 = C.<>c__DisplayClass0.CS$<>9__CachedAnonymousMethodDelegate2 == null)
        {
            C.<>c__DisplayClass0.CS$<>9__CachedAnonymousMethodDelegate2 =
                            new Action<int>(C.<>c__DisplayClass0.CS$<>9__inst.<M>b__1);
        }
    }
}

Ahora podemos ver que el delegado ahora se eleva a una clase privada dentro de C, un comportamiento similar al que estamos acostumbrados a ver cuando cerramos una instancia variable / campo (cierre).

Sé que este es un detalle de implementación que puede estar sujeto a cambios en cualquier momento dado.

Todavía me pregunto, ¿cuáles son los beneficios de levantar el delegado en una nueva clase y almacenarlo en caché allí sobre simplemente almacenarlo en caché en el sitio de la llamada?

Editar:

Este número habla del mismo comportamiento que se ha pedido aquí.