C#筆記 – 匿名類型與匿名方法

匿名方法

• 匿名方法允許你指定一個內聯委托實例的操作，作為創建委托實例表達式的一部分。

• 語法：

  • 使用delegate關鍵字

  • delegate(參數)
    {
        代碼塊
    };

  • 匿名方法的結果是一個委托實例

    • 不同於一般委托實例，逆變性不適用於匿名方法，必須指定和委托類型完全匹配的參數類型

  • 在IL中，編譯器會在已知類（匿名方法所在的類）的內部生成一個方法，並使用創建委托實例時的操作，就像一個普通方法一樣。

    • 但這些方法的名稱是不友好（unspeakable）的，因此，它們只在IL中有效，在C#中則無效，因此無法在C#代碼中直接引用它們。

    • //C# 層
      static void Main(string[] args)
      {
          Action<string> printReverse = delegate (string text)
          {
              char[] chars = text.ToCharArray();
              Array.Reverse(chars);
              Console.WriteLine(new string(chars));
          }
          
          printReverse("Let It Out");
      }

    • //IL層
      //入口
      //Main : void(string[])
      //臨時創建一個類
      IL_000a: ldsfld class CSharpInDepth.Program/'<>c' CSharpInDepth.Program/'<>c'::'<>9'
      //在臨時類裡生成一個方法
      IL_000f: ldftn instance void CSharpInDepth.Program/'<>c'::'<Main>b__6_0'(string)
      IL_0015: newobj instance void class [System.Runtime]System.Action`1<string>::.ctor(object,
      native int)
      IL_001a: dup
      IL_001b: stsfld class [System.Runtime]System.Action`1<string> CSharpInDepth.Program/'<>c'::'<>9__6_0'

    • //IL層
      //被構造的方法
      //<>c
      //<Main>b__6_0 : void(string)
      .method assembly hidebysig instance void 
      '<Main>b__6_0'(string text) cil managed
      {
      // 程式碼大小 28 (0x1c)
      .maxstack 1
      .locals init (char[] V_0)
      IL_0000: nop
      IL_0001: ldarg.1
      IL_0002: callvirt instance char[] [System.Runtime]System.String::ToCharArray()
      IL_0007: stloc.0
      IL_0008: ldloc.0
      IL_0009: call void [System.Runtime]System.Array::Reverse<char>(!!0[])
      IL_000e: nop
      IL_000f: ldloc.0
      IL_0010: newobj instance void [System.Runtime]System.String::.ctor(char[])
      IL_0015: call void [System.Console]System.Console::WriteLine(string)
      IL_001a: nop
      IL_001b: ret
      } // end of method '<>c'::'<Main>b__6_0'

• 返回值

  • 有的委托是可以有返回值的，比如Predicate和Func

  • 當需要匿名函數進行值的返回時，不需要聲明返回值類型，編譯器自己會檢查是否所有可能的返回值都兼容於委托類型（編譯器會嘗試將匿名方法轉換成該委托類型）

    • 當匿名方法返回一個值時，真的是從匿名方法返回，不是從創建的委托實例的方法返回

  • Predicate<int> isEven = delegate (int x) { return x % 2 == 0; }; //兼容的返回值類型：bool
    Func<int, string> test = delegate (int y) { return $"Answer:{y}"; }; //兼容的返回值類型：最後一個參數

• 忽略委托參數

  • 如果不關心委托的參數，可以不用聲明它們

捕獲變量

• 閉包

  • 一個函數除了能通過提供給它的參數交互之外，還能同環境進行更大程度的互動

  • 外部變量（outer variable）

    • 在包括匿名方法的作用域（scope）中的局部變量或參數（不包括ref和out參數）。在類的實例成員內部的匿名方法中，this引用也被認為是一個外部變量

  • 捕獲（的外部）變量（captured (outer) variable）

    • 在匿名方法內部使用的外部變量

    • 在閉包定義中，「函數」指的是匿名方法，「與之交互的環境」指的是匿名方法捕獲到的變量集

• 簡言之，匿名方法能使用在聲明該匿名方法的方法內部定義的局部變量

• void EnclosingMethod()
  {
      int outerVar = 5; //外部變量
      string capturedVar = "captured"; //捕獲變量
      
      if(DateTime.Now.Hour == 23)
      {
          int normalLocalVar = DateTime.Now.Minute; //普通方法的局部變量
          Console.WriteLine(normalLocalVar);
      }
      
      MethodInvoker x = delegate()
      {
          string anonLocal = "local to anonymous method"; //匿名方法的局部變量
          Console.WriteLine(capturedVar + anonLocal); //捕獲變量的使用
      };
      
      x();
  }

• 行為

  • 被匿名方法捕獲的是「變量」，而不是創建委托實例時「該變量的值」

  • string captured = "before x is created";
    ​
    TEST t = delegate
    {
        Console.WriteLine(captured);
        captured = "changed by t";
    };
    ​
    captured = "directly before x is invoked";
    t(); //Expected: directly before x is invoked
    ​
    Console.WriteLine(captured); //Expected: changed by t
    ​
    captured = "before second invocation";
    t(); //Expected before second invocation

  • 創建委托實例時，不會執行匿名函數內的代碼

  • 在整個方法中，使用的始終是「同一個變量」

• 用途

  • 捕獲變量能簡化避免專門創建一些類來存儲一個委托需要處理的信息

  • List<Person> FindAllYoungerThan(List<Person> people, int limit)
    {
        return people.FindAll(delegate(Person person)
                              {
                                  return person.Age < limit;
                              });
    }

  • 以上面的代碼為例，如果只有匿名方法而沒有捕獲變量，就只能在匿名方法中使用一個「硬編碼」的限制年齡，而不能使用作為參數傳遞的limit

• 捕獲變量的生存期

  • 對於一個捕獲變量，只要還有任何委托實例在引用它，它就會一直存在

  • void Main()
    {
        TEST t = CreateDelegateInstance(); //5
        //counter只存活在CreateDelegateInstance中
        //而CreateDelegateInstance在上面已經完成了調用，生命周期完結
        //但由於t裡面還捕捉著counter，因此counter生存期被延長
        t(); //6
        t(); //7
    }
    ​
    static TEST CreateDelegateInstance()
    {
        int counter = 5;
        TEST t = delegate
        {
            Console.WriteLine(counter);
            counter++;
        };
    ​
        t();
        return t;
    }

  • 在調用CreateDelegateInstance時，counter的值理所當應是可用的

  • 在方法返回後，雖然counter已隨著CreateDelegateInstance的棧幀被銷毀時而消失

  • 儘管如此，編譯器創建了一個額外的類來容納變量。CreateDelegateInstance方法擁有對該類的一個實例的引用，所以它能使用counter

  • 另外，委托也有對該實例的一個引用，這個實例和其他實例一樣都在堆上。除非委托準備好被垃圾回收，否則那個實例是不會被回收的。

• 局部變量實例化

  • 局部變量每被聲明一次，它就會被實例化一次。

  • 假如不涉及任何匿名方法，局部變量所需的空間都在方法開始時在棧上分配，所以不會產生每次循環迭代都「重新聲明」變量的開銷

  • 但是以下面代碼為例：

    • 如果把變量捕獲，那在每一次循環裡聲明的局部變量，都會再實例化一個新的同名實例

    • 如果聲明在循環外面，那捕獲的只有那「一個」變量實例，也不會重新實例化

  • List<TEST> list = new List<TEST>();
    //int counter = 10;
    for (int i = 0; i < 5; i++)
    {
        int counter = i * 10;
    ​
        list.Add(delegate
                 {
                     Console.WriteLine(counter);
                     counter++;
                 });
    }

  • 當一個變量被捕獲時，捕捉的是變量的實例。如果在循環裡捕獲counter，第一次循環時捕獲的變量與第二次循環時捕獲的變量是不同的

  • 而循環的初始部分聲明的變量也是只要被實例化一次（int i）

    • 因此，如果想捕獲循環變量在一次特定循環迭代中的值，必須在循環內部引入另一個變量，并將循環變量的值賦給它，再捕捉這個新的變量

• 同時使用共享與非共享變量

  • TEST[] delegates = new TEST[2];
    ​
    int outside = 0;
    for (int i = 0; i < 2; i++)
    {
        int inside = 0;
        delegates[i] = delegate
        {
            Console.WriteLine($"{outside}, {inside}");
            outside++;
            inside++;
        };
    }
    ​
    TEST first = delegates[0];
    TEST second = delegates[1];
    ​
    //Outside, Inside
    first(); //0, 0
    first(); //1, 1
    first(); //2, 2
    ​
    second(); //3, 0
    second(); //4, 1