首先，我覺得，一個概念，如果不理解也不影響使用的話，那麼，就沒必要去理解它、去學習它。閉包就是這樣一個概念，你不理解它也能很好的用它。俺這兩年寫as3程式，是天天在和它打交道，甚至有過一個function套一個，一個方法中套了20多個function的極端例子，但從未深究過它是怎麼實現的，它就像水和空氣一樣，我們不需要知道水是H2O，空氣是氧氣氮氣二氧化碳等的混合物，也活的好好的。

其次，我覺得，網上對閉包概念的解釋都太狹隘了，看得人蛋疼，就像回到了i++,++i時代一樣。如果非要去理解這個概念，像那樣去理解，則收穫太小，不值得。

維基百科上對閉包的解釋就很經典：在電腦科學中，閉包（Closure）是詞法閉包（Lexical Closure）的簡稱，是引用了自由變數的函式。這個被引用的自由變數將和這個函式一同存在，即使已經離開了創造它的環境也不例外。所以，有另一種說法認為閉包是由函式和與其相關的引用環境組合而成的實體。Peter J. Landin 在1964年將術語閉包定義為一種包含環境成分和控制成分的實體。

下面是我理解的閉包概念。

先看看數學上的閉包。

(1,5) 是一個區間，但對這個區間做分析、計算什麼的，經常會用到1和5這兩個不屬於這個區間的值，[1,5]就是(1,5)的閉包。

在生活上，我們辦事情，找A部門，A部門說，你先得找B部門蓋個章，B部門說，你先得找C部門蓋個章，C部門說，這個東西不是我們的職權範圍…… 踢皮球，這就是非閉包。閉包就是負責到底，你找到A部門，A部門接待的那個人負責到底，他/她去協調B部門和C部門。

在工程上，閉包就是專案經理，負責排程專案所需要的資源。老闆、客戶有什麼事情，直接找專案經理即可，不用再去找其它的人。

在程式語言中，閉包就是一種語法糖，它以很自然的形式，把我們的目的和我們的目的所涉及的資源全給自動打包在一起，以某種自然、儘量不讓人誤解的方式讓人來使用。至於其具體實現，我個人意見，在不影響使用的情況下，不求甚解即可。在很多情況下，需要在一段程式碼裡去訪問外部的區域性變數，不提供這種語法糖，需要寫非常多的程式碼，有了閉包這個語法糖，就不用寫這麼多程式碼，自然而然的就用了。

這樣一來，可以把閉包從一個語法機制提升為一種設計原則：閉包是從使用者角度考慮的一種設計概念，它基於對上下文的分析，把齷齪的事情、複雜的事情和外部環境互動的事情都自己做了，留給使用者一個很自然的介面。

在這個原則下，函式式語言中，那種所謂的閉包只是一種“閉包”，還有大量的其它型別的“閉包”等待發現和實現。

下面舉出一些閉包設計原則的正例和反例。

正例：Flex中的資料繫結語法就是一種“閉包”。x="{b.num + c.num}"，對於這個語法，編譯器自動去上下文中尋找叫 b 和 c 的變數，然後再找他們內部 num 變數，如果他們都是可繫結的話，則自動給它們新增上繫結鏈，當 b, c, num 等有任一變動時，更新 x 的值。

反例：Winform 中的設計就違反了閉包原則，當不是在該UI執行緒中，更新某些控制元件的值時，會丟擲異常。只能去invoke呼叫，而invoke的介面很難用，相信很多人對這東東極其反感。

閉包不一定是語法糖。當我們不能直接擴充套件編譯器時，我們就無法增加語法糖來實現閉包機制，這時，就要用現有的語言機制來實現了。 下面，我們來對winform的invoke方法進行改造，使它滿足閉包原則。下面是程式碼：

public class ControlFuncContext 
    { 
        public Control Control { get; private set; } 
        public Delegate Delegate { get; private set; }
        public ControlFuncContext(Control ctl, Delegate d) 
        { 
            this.Control = ctl; 
            this.Delegate = d; 
        }
        public void Invoke0() 
        { 
            if (Control.IsHandleCreated == true) 
            { 
                try
                { 
                    Delegate.DynamicInvoke(); 
                } 
                catch(ObjectDisposedException ex) 
                { 
                } 
            } 
        }
        public void Invoke1<T>(T obj) 
        { 
            if (Control.IsHandleCreated == true) 
            { 
                try
                { 
                    Delegate.DynamicInvoke(obj); 
                } 
                catch (ObjectDisposedException ex) 
                { 
                } 
            } 
        }
        public void Invoke2<T0,T1>(T0 obj0, T1 obj1) 
        { 
            if (Control.IsHandleCreated == true) 
            { 
                try
                { 
                    Delegate.DynamicInvoke(obj0, obj1); 
                } 
                catch (ObjectDisposedException ex) 
                { 
                } 
            } 
        } 
    }
    public static class FormClassHelper 
    {
        public static void InvokeAction(this Control ctl, Action action) 
        { 
            if (ctl.IsHandleCreated == true) 
            { 
                ControlFuncContext fc = new ControlFuncContext(ctl, action); 
                ctl.Invoke(new Action(fc.Invoke0)); 
            } 
        }
        public static void InvokeAction<T>(this Control ctl, Action<T> action, T obj) 
        { 
            if (ctl.IsHandleCreated == true) 
            { 
                ControlFuncContext fc = new ControlFuncContext(ctl, action); 
                ctl.Invoke(new Action<T>(fc.Invoke1<T>), obj); 
            } 
        }
        public static void InvokeAction<T0, T1>(this Control ctl, Action<T0, T1> action, T0 obj0, T1 obj1) 
        { 
            if (ctl.IsHandleCreated == true) 
            { 
                ControlFuncContext fc = new ControlFuncContext(ctl, action); 
                ctl.Invoke(new Action<T0, T1>(fc.Invoke2<T0, T1>), obj0, obj1); 
            } 
        } 
    }
使用起來很簡單，直接呼叫擴充套件方法 InvokeAction 即可，不必去考慮跨執行緒還是不跨執行緒這些“環境因素”，跨執行緒呼叫，我們已經通過使用者不必知曉的方式，把它封裝起來了。
再舉個例子，寫程式經常需要這樣一個功能：開啟一個影象檔案，然後進行處理。正常寫法很麻煩，比如，那個filter格式就很容易忘記，那麼，我們就把它閉包化，把不該讓使用者知道，不該讓使用者敲鍵盤的都給它封裝起來：
public static void OpenFile(this Form element, Action<string> callbackOnFilePath, String filter = "所有檔案|*.*")
        {
            String filePath;
            OpenFileDialog dlg = new OpenFileDialog();
            dlg.Filter = filter;
            dlg.FileOk += (object sender, CancelEventArgs e) =>
            {
                filePath = dlg.FileName;
if (callbackOnFilePath != null)
                    callbackOnFilePath(filePath);
            };
            dlg.ShowDialog();
        }
public static void OpenImageFile(this Form element, Action<String> callbackOnFilePath, String filter = "影象檔案|*.bmp;*.jpg;*.gif;*.png")
        {
            OpenFile(element, callbackOnFilePath, filter);
        }
</string>
再舉一個例子，這個例子是as3中的。在Flex中，控制元件有一個callLater 方法，在下一幀時進行呼叫。這個方法非常有用，很多時候，非Flex專案也需要這樣的一個方法。下面，我們進行模擬：
package orc.utils 
{ 
    import flash.display.Stage; 
    import flash.events.Event;
    public class CallLaterHelper 
    { 
        public function CallLaterHelper(stage:Stage, callback:Function) 
        { 
            this.callback = callback; 
            this.stage = stage;
            stage.addEventListener(Event.ENTER_FRAME, onStageEnterFrame); 
        } 
        private var stage:Stage; 
        private var callback:Function; 
        private function onStageEnterFrame(event:Event):void
        { 
            stage.removeEventListener(Event.ENTER_FRAME, onStageEnterFrame); 
            if(callback != null) 
            { 
                callback(); 
            } 
        } 
    } 
}

然後在基礎控制元件中，提供callLater方法：

public function callLater(callback:Function):void
{ 
    new CallLaterHelper(this.stage,callback); 
}

總結：

1. 閉包是一種設計原則，它通過分析上下文，來簡化使用者的呼叫，讓使用者在不知曉的情況下，達到他的目的；
2. 網上主流的對閉包剖析的文章實際上是和閉包原則反向而馳的，如果需要知道閉包細節才能用好的話，這個閉包是設計失敗的