Neden bazı C # lambda ifadeleri statik yöntemlerle derlenir?

Aşağıdaki kodda da görebileceğiniz gibi, bir Action<>nesneyi değişken olarak tanımladım.

Bu eylem yöntemi temsilcisinin neden statik bir yöntem gibi davrandığını lütfen bana bildirin.

Neden trueaşağıdaki kodda geri dönüyor ?

Kod:

public static void Main(string[] args)
{
    Action<string> actionMethod = s => { Console.WriteLine("My Name is " + s); };

    Console.WriteLine(actionMethod.Method.IsStatic);

    Console.Read();
}

Çıktı:

Bunun nedeni büyük olasılıkla kapanış olmamasıdır, örneğin:

int age = 25;
Action<string> withClosure = s => Console.WriteLine("My name is {0} and I am {1} years old", s, age);
Action<string> withoutClosure = s => Console.WriteLine("My name is {0}", s);
Console.WriteLine(withClosure.Method.IsStatic);
Console.WriteLine(withoutClosure.Method.IsStatic);

Bu, falseiçin withClosureve trueiçin çıktı verecektir withoutClosure.

Bir lambda ifadesi kullandığınızda, derleyici yönteminizi içerecek küçük bir sınıf oluşturur, bu, aşağıdaki gibi bir şeye derlenir (gerçek uygulama büyük olasılıkla biraz değişir):

private class <Main>b__0
{
    public int age;
    public void withClosure(string s)
    {
        Console.WriteLine("My name is {0} and I am {1} years old", s, age)
    }
}

private static class <Main>b__1
{
    public static void withoutClosure(string s)
    {
        Console.WriteLine("My name is {0}", s)
    }
}

public static void Main()
{
    var b__0 = new <Main>b__0();
    b__0.age = 25;
    Action<string> withClosure = b__0.withClosure;
    Action<string> withoutClosure = <Main>b__1.withoutClosure;
    Console.WriteLine(withClosure.Method.IsStatic);
    Console.WriteLine(withoutClosure.Method.IsStatic);
}

Ortaya çıkan Action<string>örneklerin aslında bu oluşturulan sınıflardaki yöntemlere işaret ettiğini görebilirsiniz .

"Eylem yöntemi", yalnızca uygulamanın bir yan etkisi olarak statiktir. Bu, yakalanan değişkenlerin olmadığı anonim bir yöntem durumudur. Yakalanan değişken olmadığından, yöntemin genel olarak yerel değişkenler için olanların dışında ek yaşam süresi gereksinimleri yoktur. Diğer yerel değişkenlere referans verdiyse, ömrü bu diğer değişkenlerin yaşam süresine kadar uzanır (bkz. Bölüm L.1.7, Yerel değişkenler ve bölüm N.15.5.1, Yakalanan dış değişkenler , C # 5.0 belirtiminde).

C # belirtiminin, "anonim sınıflara" değil, yalnızca "ifade ağaçlarına" dönüştürülen anonim yöntemlerden bahsettiğine dikkat edin. İfade ağacı, örneğin Microsoft derleyicisinde ek C # sınıfları olarak temsil edilebilirken, bu uygulama gerekli değildir (C # 5.0 belirtiminde bölüm M.5.3 tarafından onaylandığı gibi). Bu nedenle, anonim işlevin statik olup olmadığı tanımlanmamıştır. Ayrıca K.6 bölümü ifade ağaçlarının detaylarına çok açık bırakmaktadır.

Delege önbelleğe alma davranışı Roslyn'de değiştirildi. Önceden, belirtildiği gibi, değişkenleri yakalamayan herhangi bir lambda ifadesi staticçağrı sitesinde bir yöntemde derleniyordu . Roslyn bu davranışı değiştirdi. Şimdi, değişkenleri yakalayan veya yakalayan herhangi bir lambda, bir görüntüleme sınıfına dönüştürülür:

Bu örnek verildiğinde:

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

Yerel derleyici çıktısı:

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);
    }
}

Roslyn:

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);
        }
    }
}

Roslyn'deki temsilci önbelleğe alma davranışı değişiklikleri, bu değişikliğin neden yapıldığından bahsediyor.

C # 6'dan itibaren, bu her zaman şimdi örnek yöntemlerine varsayılan olacaktır ve hiçbir zaman statik actionMethod.Method.IsStaticolmayacaktır (bu nedenle her zaman yanlış olacaktır).

Buraya bakın: Neden yakalama içermeyen bir lambda C # 5'te bir statikten C # 6'daki bir örnek yöntemine değişti?

ve burada: CSC ve Roslyn derleyicisinin statik lambda ifadesi değerlendirmesindeki fark nedir?

Yöntemin kapanması yoktur ve ayrıca statik bir yöntemin kendisine (Console.WriteLine) başvurur, bu nedenle statik olmasını beklerim. Yöntem, bir kapatma için çevreleyen anonim bir tür bildirir, ancak bu durumda gerekli değildir.