淺談C#的函式建立和閉包

蘑菇先生發表於2015-02-28
C#函式

動態建立函式

大多數同學，都或多或少的使用過。回顧下c#中動態建立函式的進化：

C# 1.0中：

  public delegate string DynamicFunction(string name);
  public static DynamicFunction GetDynamicFunction()
  {
      return GetName;
  }
  static string GetName(string name)
  {
      return name;
  }
  var result = GetDynamicFunction()("mushroom");

3.0寫慣了是不是看起來很繁瑣、落後。 剛學委託時，都把委託理解成函式指標，也來看下用函式指標實現的：

char GetName(char p);
typedef char (*DynamicFunction)(char p);
DynamicFunction GetDynamicFunction()
{
    return GetName;
}
char GetName(char p)
{
    return p;
};
char result = GetDynamicFunction()('m');

對比起來和c# 1.0幾乎一模一樣了(引用/指標差別)，畢竟是同一家族的。

C# 2.0中，增加匿名函式：

      public delegate string DynamicFunction(string name);
      DynamicFunction result2 = delegate(string name)
      {
          return name;
      };

C# 3.0中，增加Lambda表示式，華麗的轉身：

 public static Func<string, string> GetDynamicFunction()
 {
        return name => name;
 }
 var result = GetDynamicFunction()("mushroom");

匿名函式不足之處

雖然增加Lambda表示式，已經極大簡化了我們的工作量。但確實有些不足之處：

var result = name => name;

這些寫編譯時是報錯的。因為c#本身強型別語言的，提供var語法糖只是為了省去宣告確定型別的工作量。 編譯器在編譯時必須能夠完全推斷出各引數的型別才行。程式碼中的name引數型別，顯然在編譯時無法推斷出來的。

var result = (string name) => name;
Func<string, string> result2 = (string name) => name;
Expression<Func<string, string>> result3 = (string name) => name;

上面直接宣告name型別呢，很遺憾這樣也是報錯的。程式碼中已經給出答案了，編譯器推斷不出右邊表示式是屬於Func<string, string>型別還是Expression<Func<string, string>>型別。

 dynamic result = name => name;
 dynamic result1 = (Func<string,string>)(name => name);

用dynamic呢，同樣編譯器也分不出右邊是個委託，我們顯示轉換下就可以了。

Func<string, string> function = name => name;
DynamicFunction df = function;

這裡定義個func委託，雖然引數和返回值型別都和DynamicFunction委託一樣，但編譯時還是會報錯：不能隱式轉換Func<string, string>到DynamicFunction，2個型別是不相容的。

理解c#中的閉包

談論到動態建立函式，都要牽扯到閉包。閉包這個概念資料很多了，理論部分這裡就不重複了。 來看看c#程式碼中閉包：

        Func<Func<int>> A = () =>
        {
            var age = 18;
            return () =>  //B函式
            {
                return age;
            };
        };
        var result = A()();

上面就是閉包，可理解為就是： 跨作用域訪問函式內變數，也有說帶著資料的行為。
C#變數作用域一共有三種，即：類變數，例項變數，函式內變數。子作用域訪問父作用域的變數(即函式內訪問例項/類變數)在我們看來理所當然的，也符合我們一直的程式設計習慣。
例子中匿名函式B是可以訪問上層函式A的變數age。對於編譯器而言，A函式是B函式的父作用域，所以B函式訪問父作用域的age變數是符合規範的。

       int age = 16;
        void Display()
        {
            Console.WriteLine(age);  
            int age = 18;
            Console.WriteLine(age);
        }

上面編譯會報錯未宣告使用，編譯器檢查到函式內宣告age後，作用域就會覆蓋父作用域的age，(像JS就undefined了)。

        Func<int> C = () =>
         {
             var age = 19;
             return age;
         };

上面宣告個同級函式C，那麼A函式是無法訪C函式中的age變數的。 簡單來說就是不可跨作用域訪問其他函式內的變數。 那編譯器是怎麼實現閉包機制的呢？

如上圖，答案是升級作用域，把A函式升級為一個例項類作用域。 在編譯程式碼期間，編譯器檢查到B函式使用A函式內變數時，會自動生成一個匿名類x，把原A函式內變數age提升為x類的欄位(即例項變數)，A函式提升為匿名類x的例項函式。下面是編譯器生成的程式碼(精簡過)：

class Program1
{
    static Func<Func<int>> CachedAnonymousMethodDelegate2;
    static void Main(string[] args)
    {
        Func<Func<int>> func = new Func<Func<int>>(Program1.B);
        int num = func()();
    }
    static Func<int> B()
    {
        DisplayClass cl = new DisplayClass();
        cl.age = 18;
        return new Func<int>(cl.A);
    }
}
sealed class DisplayClass
{
    public int age;
    public int A()
    {
        return this.age;
    }
}

我們再來看個複雜點的例子：

    static Func<int, int> GetClosureFunction()
    {
        int val = 10;
        Func<int, int> interAdd = x => x + val;
        Console.WriteLine(interAdd(10));
        val = 30;
        Console.WriteLine(interAdd(10));
        return interAdd;
    }
  Console.WriteLine(GetClosureFunction()(30));

輸出結果是20、40、60。 當看到這個函式內變數val通過閉包被傳遞的時候，我們就知道val不僅僅是個函式內變數了。之前我們分析過編譯器怎麼生成的程式碼，知道val此時是一個匿名類的例項變數，interAdd是匿名類的例項函式。所以無論val傳遞多少層，它的值始終保持著，直到離開這個(鏈式)作用域。

關於閉包，在js當中談論的比較多，同理，可以對比理解下：

function A() {
    var age = 18;
    return function () {
        return age;
    }
}
A()();

閉包的優點

  • 對變數的保護。想暴露一個變數值，但又怕宣告類或例項變數會被其他函式汙染，這時就可以設計個閉包，只能通過函式呼叫來使用它。
  • 邏輯連續性和變數保持。 A()是執行一部分邏輯，A()()僅接著A()邏輯繼續走下去，在這個邏輯上下文期間，變數始終都被保持著，可以隨意使用。

相關文章