淺談C#中閉包

先想說明一點，雖然有這樣那樣的很差的心態(好比中文技術書)，但整體來講，國內的技術人員仍是喜歡分享和教導別人的，這點個人我的感覺和以前在園子裏看到的朋友的感覺偏偏相反。我的認爲其實國內不少技術網友都是很熱心的，可能由於語言問題同一個技術熱點會稍稍落後國外一些，但一些成熟的或者基礎的概念均可以找到很細緻的中文介紹，特別是關於閉包。由於它的字面解釋確實很繞，因此基本全部試圖解釋這一名詞的同窗都是儘可能用本身認爲最通俗易懂的方式來進行講解。閒話扯遠了，這裏我就用C#語言來給你們解釋下閉包吧。

　　其實要提到閉包，咱們還得先提下變量做用域和變量的生命週期。

　　在C#裏面，變量做用域有三種，一種是屬於類的，咱們常稱之爲field；第二種則屬於函數的，咱們一般稱之爲局部變量；還有一種，其實也是屬於函數的，不過它的做用範圍更小，它只屬於函數局部的代碼片斷，這種一樣稱之爲局部變量。這三種變量的生命週期基本均可以用一句話來講明，每一個變量都屬於它所寄存的對象，即變量隨着其寄存對象生而生和消亡。對應三種做用域咱們能夠這樣說，類裏面的變量是隨着類的實例化而生，同時伴隨着類對象的資源回收而消亡(固然這裏不包括非實例化的static和const對象)。而函數(或代碼片斷)的變量也隨着函數(或代碼片斷)調用開始而生，伴隨函數(或代碼片斷)調用結束而自動由GC釋放，它內部變量生命週期知足先進後出的特性。

　　那麼這裏有沒有例外呢?

　　答案是有的，不過在提這點以前，我還須要給各位另一個名詞。都說C#就是MS版本的Java，這話在.NET 1.0可能能夠這麼說，但自2.0以後C#就能夠自豪的說它絕非java了，這裏面委託有很大的功勞。若是用過Java和C#的人而且嘗試過寫WinForm程序時所有手寫實現代碼的人就會有這樣一個感覺，一樣的click事件，在Java中必需要無故的套個匿名類，但在c#中，你是能夠直接將函數名+=到事件以後而不須要顯示寫上匿名委託的對象類型的。由於編譯器會幫你作這部分工做，在3.0和之後的版本之中，微軟將委託的用法更是發揮的淋漓精緻，不管是簡潔的Lamda仍是通俗易懂的LINQ，都是源自委託的。

　　你可能要問，委託和咱們今天要講的閉包又有什麼關係呢?

　　咱們知道，C#, Java和JavaScript, Ruby, Python這些語言不一樣，在C#和Java的世界裏面，原子對象就是類(固然還有struct和基本變量)，而不是不少動態語言中的函數，咱們能夠實例化一個類，實例化一個變量，但不能夠直接new 一個函數。也就是表面上看，咱們是沒辦法像js那樣將函數進行實例化和傳遞的。這也是爲何直到Java 7閉包才被姍姍來遲的加入Java特性中。但對C#來講這些只是表象，我剛學C#的時候，看到最多的解釋委託的話就是：委託啊，就至關於C++裏面的函數指針啦。這句話雖然籠統，但確實有必定道理，經過委託特別是匿名委託這層對象的包裝，咱們就能夠突破沒法將函數當作對象傳遞的限制了。

　　好像這裏仍是沒講到閉包和委託的關係，好吧，我太囉嗦了，下面從概念開始講。

　　閉包其實就是使用的變量已經脫離其做用域，卻因爲和做用域存在上下文關係，從而能夠在當前環境中繼續使用其上文環境中所定義的一種函數對象。

　　好拗口，程序員，仍是用示例來講明更好理解。

　　首先來個最簡單的JavaScript中經常見到的關於閉包的例子：

function f1(){
　　var n = 999;
　　return function(){
　　　   alert(n); // 999
        return n;
　　}
}
var a = f1();
alert(a());

　　這段代碼翻譯成C#代碼就是這樣：

public class TCloser
{
    public Func<int> T1()
    {
        var n = 999;
        return () =>
        {
            Console.WriteLine(n);
            return n;
        };
    }
}

class Program
{
    static void Main()
    {
        var a = new TCloser();
        var b = a.T1();
        Console.WriteLine(b());
    }
}

　　從上面的代碼咱們不難看到，變量n其實是屬於函數T1的局部變量，它原本生命週期應該是伴隨着函數T1的調用結束而被釋放掉的，但這裏咱們卻在返回的委託b中仍然能調用它，這裏正是閉包所展現出來的威力。由於T1調用返回的匿名委託的代碼片斷中咱們用到了n，而在編譯器看來，這些都是合法的，由於返回的委託b和函數T1存在上下文關係，也就是說匿名委託b是容許使用它所在的函數或者類裏面的局部變量的，因而編譯器經過一系列動做(具體動做咱們後面再說)使b中調用的函數T1的局部變量自動閉合，從而使該局部變量知足新的做用範圍。

　　所以，若是你看到.NET中的閉包，你就能夠像js中那樣理解它，因爲返回的匿名函數對象是在函數T1中生成的，所以至關於它是屬於T1的一個屬性。若是你把T1的對象級別往上提高一個層次就很好理解了，這裏就至關於T1是一個類，而返回的匿名對象則是T1的一個屬性，對屬性而言，它能夠調用它所寄存的對象T1的任何其餘屬性或者方法，包括T1寄存的對象TCloser內部的其餘屬性。若是這個匿名函數會被返回給其餘對象調用，那麼編譯器會自動將匿名函數所用到的方法T1中的局部變量的生命週轉期自動提高，並與匿名函數的生命週期相同，這樣就稱之爲閉合。

　　也許你會說，這個返回的委託包含的變量n只是編譯器經過某種方式隱藏的對這個委託對象的一個一樣對象的賦值吧，那麼咱們再對比下面兩個方法：

public class TCloser
{
    public Func<int> T1()
    {
        var n = 999;
        Func<int> result = () =>
        {
            return n;
        };
        n = 10;
        return result;
    }

    public dynamic T2()
    {
        var n = 999;
        dynamic result = new { A = n };
        n = 10;
        return result;
    }
    static void Main()
    {
        var a = new TCloser();
        var b = a.T1();
        var c = a.T2();
        Console.WriteLine(b());
        Console.WriteLine(c.A);
    }
}

　　最後輸出結果是什麼呢？答案是10和999，由於閉包的特性，這裏匿名函數中所使用的變量就是實際T1中的變量，與之相反的是，匿名對象result裏面的A只是初始化時被賦予了變量n的值，它並非n，因此後面n改變以後A並未隨之而改變。這正是閉包的魔力所在。   

　　你可能會好奇.NET自己並不支持函數對象，那麼這樣的特性又是從何而來呢？答案是編譯器，咱們一看IL代碼便會明白了。

　　首先我給出C#代碼：

public class TCloser
{
    public Func<int> T1()
    {
        var n = 10;
        return () =>
        {
            return n;
        };
    }

    public Func<int> T4()
    {
        return () =>
        {
            var n = 10;
            return n;
        };
    }
}

　　這兩個返回的匿名函數的惟一區別就是返回的委託中變量n的做用域不同而已，T1中變量n是屬於T1的，而在T4中，n則是屬於匿名函數自己的。但咱們看看IL代碼就會發現這裏面的大不一樣了：

.method public hidebysig instance class [mscorlib]System.Func`1<int32> T1() cil managed{
    .maxstack 3
    .locals init (
        [0] class ConsoleApplication1.TCloser/<>c__DisplayClass1 CS$<>8__locals2,
        [1] class [mscorlib]System.Func`1<int32> CS$1$0000)
    L_0000: newobj instance void ConsoleApplication1.TCloser/<>c__DisplayClass1::.ctor()
    L_0005: stloc.0
    L_0006: nop
    L_0007: ldloc.0
    L_0008: ldc.i4.s 10
    L_000a: stfld int32 ConsoleApplication1.TCloser/<>c__DisplayClass1::n
    L_000f: ldloc.0
    L_0010: ldftn instance int32 ConsoleApplication1.TCloser/<>c__DisplayClass1::<T1>b__0()
    L_0016: newobj instance void [mscorlib]System.Func`1<int32>::.ctor(object, native int)
    L_001b: stloc.1
    L_001c: br.s L_001e
    L_001e: ldloc.1
    L_001f: ret
}
 
.method public hidebysig instance class [mscorlib]System.Func`1<int32> T4() cil managed
{
    .maxstack 3
    .locals init (
        [0] class [mscorlib]System.Func`1<int32> CS$1$0000)
    L_0000: nop
    L_0001: ldsfld class [mscorlib]System.Func`1<int32> ConsoleApplication1.TCloser::CS$<>9__CachedAnonymousMethodDelegate4
    L_0006: brtrue.s L_001b
    L_0008: ldnull
    L_0009: ldftn int32 ConsoleApplication1.TCloser::<T4>b__3()
    L_000f: newobj instance void [mscorlib]System.Func`1<int32>::.ctor(object, native int)
    L_0014: stsfld class [mscorlib]System.Func`1<int32> ConsoleApplication1.TCloser::CS$<>9__CachedAnonymousMethodDelegate4
    L_0019: br.s L_001b
    L_001b: ldsfld class [mscorlib]System.Func`1<int32> ConsoleApplication1.TCloser::CS$<>9__CachedAnonymousMethodDelegate4
    L_0020: stloc.0
    L_0021: br.s L_0023
    L_0023: ldloc.0
    L_0024: ret
}

　　看IL代碼你就會很容易發現其中究竟了，在T1中，函數對返回的匿名委託構造的是一個類，名稱爲newobj instance void ConsoleApplication1.TCloser/<>c__DisplayClass1::.ctor()，而在T4中，則是仍然是一個普通的Func委託，只不過級別變爲類級別了而已。

　　那咱們接着看看T1中聲明的類c__DisplayClass1是何方神聖：

.class auto ansi sealed nested private beforefieldinit <>c__DisplayClass1
    extends [mscorlib]System.Object{
    .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor()
    .method public hidebysig specialname rtspecialname instance void .ctor() cil managed{}
    .method public hidebysig instance int32 <T1>b__0() cil managed{}
    .field public int32 n
}

　　看到這裏想必你已經明白了，在C#中，原來閉包只是編譯器玩的花招而已，它仍然沒有脫離.NET對象生命週期的規則。它將須要修改做用域的變量直接封裝到返回的類中，變成類的一個屬性n，從而保證了變量的生命週期不會隨函數T1調用結束而結束，由於變量n在這裏已經成了返回的類的一個屬性了。

　　看到這裏我想你們應該大致上瞭解C#閉包的前因後果了吧。C#中，閉包其實和類中其餘屬性、方法是同樣的，它們的原則都是下一層能夠暢快的調用上一層定義的各類設定，但上一層則不具有訪問下一層設定的能力。即類中方法裏的變量能夠自由訪問類中的全部屬性和方法，而閉包又能夠訪問它的上一層即方法中的各類設定。但類不能夠訪問方法的局部變量，同理，方法也不能夠訪問其內部定義的匿名函數所定義的局部變量。

　　這正是C#中的閉包，它經過超越Java語言的委託打下了閉包的第一步基礎，隨後又經過各類語法糖和編譯器來實現現在在.NET世界全面開花的Lamda和LINQ，也使得咱們可以編寫出更加簡潔優雅的代碼。

　　附：後面是吐槽，與上文無關，你們能夠略過，這篇文章其實兩年以前在給同事講C#閉包的時候就有想法整理出來和你們分享了，不過由於生活，工做，或許主要仍是本身太懶的緣由而拖着沒動筆，到今天早上看到園友抱怨國內教書育人的氛圍才最終決定利用晚上時間把它整理，而後放出來。我我的認爲國內技術圈子的氛圍尚可，雖然仍然有不少浮躁和易怒在圈子裏徘徊，但咱們想一想國內IT人的生存空間就容易理解了。天天最理想的狀況朝9晚6的幹活，晚上加班，週末加班這些都是常事，而對咱們而言，只要想寫出一些通過細細思考的東西都至少須要2個小時以上，並且最好中間不要有人來打擾，這也就註定咱們在白天工做時候很難徹底有時間靜下來組織語言，刨掉這些時間，留給咱們本身的生活時間又有多少呢？因此我每次看到有園友發表帖子的時間是晚上1點，2點甚至更晚，都絕不意外，

　　咱們並不是專業寫手，也不像國外IT人那樣有充足的閒暇時光能夠鑽研本身的最愛，咱們賺着他們的零頭，買着比他們本子價格更貴的筆記本，擔着比他們更高房價的壓力來生活，這樣的生活條件下咱們這些可愛的社區(不只限於cnblogs, javaeye, phpchina等)Geek們仍然如此活躍和熱情，你還能抱怨什麼呢？你要知道你看到的每篇文章(若是是工做人士的話)都是他們晚上從9點寫到12點的生活點滴啊。

　　因此，之後不要抱怨國內IT氛圍吧，相對這個社會其餘各行各業的浮躁，我以爲咱們的IT圈子已是很樂於分享的一個羣體了。並且除了由於「天下武功，源自歐美，滯後於英語國家」的緣故，咱們有些技術確實要晚些才能跟上國外社區的腳步，但對於一些基礎知識的解釋，已經有不少中文的文章解釋得很不錯了。像我之前在理解閉包的時候， javaeye上看到的一大堆，像WIKI，像阮一峯的文章，我我的認爲對中文用戶是足夠了。固然，這只是我我的的觀點，你們沒必要較勁。

　　最後一點抱怨就是國內大大小小的抄襲網站，我想這也是影響咱們中文用戶查詢資料的一個重要因素吧。之前曾經嘗試過在baidu, google上搜索本身的文章，但結果至關使人失望，那些抄襲的網站歷來都不在意內容，由於這些能夠經過抄來解決，並且沒必要帶原文連接，沒必要代表做者。好像東西就是他們本身的同樣，他們惟一在意的就是SEO。這也致使我在使用google搜索的時候時常看到同一篇文章出如今某一頁的全部搜索結果中，固然，網址是千奇百怪，實在讓人無奈。有些網站即便標明瞭出處和做者，但用心略有險惡的不是給的連接，而是文字。並且,在這些抄襲者中，最讓我感到悲哀的是大名鼎鼎的敗毒文庫，我至少看到不下5篇敗毒文庫裏的文章是來自JE或者CSDN的，但在文庫裏面只有個文檔，你看不到任何做者提示或者原文連接。也許有人會說，這也多是做者本身上傳的呀，但我我的認爲這種可能性過小了，以國內IT人的風格，對敗毒即便談不上厭惡，也不多有主動去巴巴的。試想，一個國內最大的互聯網公司都不尊重IT人的勞動(希望我是錯的吧)，你又能對其餘人說什麼呢? 一樣看看國外，就我看到的DZone, WindowsPhoneGeek等，每一個都是很明確的給出原文的連接，基本上我不多看到有引用別人文章不給原文連接的文章的。而正是這些不尊重做者勞動的網站對國內互聯網資料搜索形成大量的垃圾信息。