Delegate、Predicate、Action和Func

寫在前面

• Delegate
• Predicate
• Action
• Func
• 逆變和協變

　　先說下什么是委托（Delegate），委托在C#中是一種類型，和Class是一個級別，但是我們經常把它看做是一個方法。為什么是方法？准確的說應該是回調函數，在C運行時的qsort函數獲取指向一個回調函數的指針，以便對數組中的元素進行排序。C#中提供了一種機制，就是委托，一種回調函數的機制。

　　在我們做項目的過程中，委托用到的地方很多，像線程中修改窗體的狀態、窗體控件事件和異步操作已完成等，以前我們創建委托的時候用delegate關鍵字，而且也比較麻煩，自從C#4.0有了泛型，也就有了泛型委托，使用Predicate、Action和Func我們可以更好的創建委托。

Delegate

　　我們以前定義一個委托可以這樣：

        delegate Boolean delgate1(int item);
        public void delgateCommon()
        {
            var d1 = new delgate1(delegateMethod1);
            if (d1(1))
            {

            }
        }
        static bool delegateMethod1(int item)
        {
            return false;
        }

　　通過上面簡單的示例可以看到，先創建一個delgate1的委托類型，參數類型是int，返回值時bool，下面定義一個靜態方法delegateMethod1，創建一個delgate1類型的實例，參數為delegateMethod1方法名，這個也成為訂閱或是注冊，為這個委托類型注冊一個回調方法，下面就是調用了，我們在C#創建調用一個委托就是這么簡單，其實是很復雜的，只不過這些工作是編譯器幫我們做了。

　　需要注意的是上面定義的回調方法是靜態（static），如果我們創建的不是靜態方法，也是可以，只不過調用的時候需要實例訪問。

　　靜態方法都是通過關鍵字static來定義的，靜態方法不需要實例這個對象就可以通過類名來訪問這個對象。在靜態方法中不能直接訪問類中的非靜態成員。而用實例方法則需要通過具體的實例對象來調用，並且可以訪問實例對象中的任何成員。如果用委托綁定實例方法的話需要用實例對象來訪問，所以我們在綁定實例方法到委托的時 候必須同時讓委托得到實例對象的信息，這樣才能在委托被回調的時候成功執行這個實例方法。也就是說，當綁定實例方法給委托的時候，參數會被設置為這個參數所在類型的實例對象。如果給委托綁定的是靜態方法，那么這個參數將被設置為NULL。

　　綜上，委托既可以綁定靜態方法也可以綁定實例方法，但是在綁定實例方法的時候，delegate的target屬性就被設置為指向這個實例方法所屬類型的一個實例對象。當綁定靜態方法時，delegate的target屬性就給NULL。

　　廢話說的有點多，下面我們看下C#泛型委托，和結合一些匿名函數，lambda表達式的應用，其實就是一些特殊的委托。

Predicate

    // 摘要:
    //     表示定義一組條件並確定指定對象是否符合這些條件的方法。
    //
    // 參數:
    //   obj:
    //     要按照由此委托表示的方法中定義的條件進行比較的對象。
    //
    // 類型參數:
    //   T:
    //     要比較的對象的類型。
    //
    // 返回結果:
    //     如果 obj 符合由此委托表示的方法中定義的條件，則為 true；否則為 false。
    public delegate bool Predicate<in T>(T obj);

　　可以看到Predicate的簽名是一個泛型參數，返回值是bool。需要注意的是T前面的in表示什么意思？請點這里。代碼可以這樣寫：

        public void delgatePredicate()
        {
            var d1 = new Predicate<int>(delegateMethod2);
            if (d1(1))
            {

            }
        }
        static bool delegateMethod2(int item)
        {
            return false;
        }

　　可以看到使用Predicate創建委托簡化了好多，我們可以自定義參數，但是只能有一個，而且返回值必須是bool類型，是不是感覺限制太多了？無返回值或是多個參數怎么辦？請看下面。

Action

    // 摘要:
    //     封裝一個方法，該方法具有兩個參數並且不返回值。
    //
    // 參數:
    //   arg1:
    //     此委托封裝的方法的第一個參數。
    //
    //   arg2:
    //     此委托封裝的方法的第二個參數。
    //
    // 類型參數:
    //   T1:
    //     此委托封裝的方法的第一個參數類型。
    //
    //   T2:
    //     此委托封裝的方法的第二個參數類型。
    [TypeForwardedFrom("System.Core, Version=3.5.0.0, Culture=Neutral, PublicKeyToken=b77a5c561934e089")]
    public delegate void Action<in T1, in T2>(T1 arg1, T2 arg2);

　　上面是Action兩個泛型參數的簽名，最多支持十六個泛型參數，可以看到Action無返回值，創建代碼如下：

        public void delgateAction()
        {
            var d1 = new Action<int>(delegateMethod3);
            var d2 = new Action<int, string>(delegateMethod4);
            d1(1);
            d2(1, "");
        }
        static void delegateMethod3(int item)
        {
        }
        static void delegateMethod4(int item, string str)
        {
        }

　　如果我們想創建的委托類型是有多個參數，而且必須要有返回值，我們怎么辦？請看下面。

Func

    // 摘要:
    //     封裝一個具有兩個參數並返回 TResult 參數指定的類型值的方法。
    //
    // 參數:
    //   arg1:
    //     此委托封裝的方法的第一個參數。
    //
    //   arg2:
    //     此委托封裝的方法的第二個參數。
    //
    // 類型參數:
    //   T1:
    //     此委托封裝的方法的第一個參數類型。
    //
    //   T2:
    //     此委托封裝的方法的第二個參數類型。
    //
    //   TResult:
    //     此委托封裝的方法的返回值類型。
    //
    // 返回結果:
    //     此委托封裝的方法的返回值。
    [TypeForwardedFrom("System.Core, Version=3.5.0.0, Culture=Neutral, PublicKeyToken=b77a5c561934e089")]
    public delegate TResult Func<in T1, in T2, out TResult>(T1 arg1, T2 arg2);

　　上面是Func兩個參數，一個返回值的簽名，和Action一樣最多支持十六個返回值，唯一的區別是Func支持自定義返回值類型，也可以看到T1、T2前修飾符是in，TResult前的修飾符是out，這個下面有說明。創建調用代碼：

        public void delgateFunc()
        {
            string hiddenMethodString = "";
            var d1 = new Func<int, bool>(delegateMethod5);
            var d2 = new Func<int, string, string>(delegate(int item, string str)
                {
                    return hiddenMethodString;//匿名方法，好處：可讀性更好，可以訪問當前上下文
                });
            var d3 = new Func<string, string>((a) => {
                return a;//lambda表達式，a作為參數，自動判斷類型，如果單條語句，省略{}
            });
            d1(1);
            d2(1, "");
            d3("");
        }
        static bool delegateMethod5(int item)
        {
            return true;
        }

　　上面的代碼中我們使用和匿名方法和lambda表達式，可以看出其中的好處，省略創建方法的過程，代碼更簡潔，在Func中使用lambda表達式是很常見的，匿名方法有個好處就是可以訪問上下文中的變量，比如hiddenMethodString，關於匿名方法和lambda表達式在這就不做解讀了，其實就是一種語法規范，隨着C#的發展，也不斷在發展變化中。

　　完整示例代碼：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Predicate_Action_Func
{
    class Program
    {
        static void Main(string[] args)
        {
            delgateCommon();
        }

        #region 常規委托
        delegate Boolean delgate1(int item);
        public void delgateCommon()
        {
            var d1 = new delgate1(delegateMethod1);
            if (d1(1))
            {
                Console.WriteLine("111");
            }
        }
        bool delegateMethod1(int item)
        {
            return true;
        }
        #endregion

        #region Predicate委托-自定義參數（參數只能一個）
        public void delgatePredicate()
        {
            var d1 = new Predicate<int>(delegateMethod2);
            if (d1(1))
            {

            }
        }
        static bool delegateMethod2(int item)
        {
            return false;
        }
        #endregion

        #region Action委托-自定義參數（參數為多個，多類型，但無返回值）
        public void delgateAction()
        {
            var d1 = new Action<int>(delegateMethod3);
            var d2 = new Action<int, string>(delegateMethod4);
            d1(1);
            d2(1, "");
        }
        static void delegateMethod3(int item)
        {
        }
        static void delegateMethod4(int item, string str)
        {
        }
        #endregion

        #region Func委托-自定義參數（參數為多個，多類型，但有返回值）
        public void delgateFunc()
        {
            string hiddenMethodString = "";
            var d1 = new Func<int, bool>(delegateMethod5);
            var d2 = new Func<int, string, string>(delegate(int item, string str)
                {
                    return hiddenMethodString;//匿名方法，好處：可讀性更好，可以訪問當前上下文
                });
            var d3 = new Func<string, string>((a) => {
                return a;//lambda表達式，a作為參數，自動判斷類型，如果單條語句，省略{}
            });
            d1(1);
            d2(1, "");
            d3("");
        }
        static bool delegateMethod5(int item)
        {
            return true;
        }
        #endregion
    }
}

逆變和協變

什么是逆變性、協變性？

　　我們這樣創建和調用委托：

        delegate object delgate1(FieldAccessException item);
        public void delgateCommon()
        {
            var d1 = new delgate1(delegateMethod1);
            Console.WriteLine(d1(new FieldAccessException()));
        }
        static string delegateMethod1(Exception item)
        {
            return "123";
        }

　　可以看出有些不同了，參數和返回類型不一致，delegateMethod1的參數類型（Exception）是委托的參數類型（FieldAccessException）的基類，delegateMethod1的返回類型（String）派生自委托的返回類型（Object），這種就是逆變和協變，編譯和運行是可以的，也就是說是被允許的，逆變和協變只能用於引用類型，不用用於值類型或void。

　　逆變性：方法獲取的參數可以是委托的參數類型的基類。

• 泛型類型參數可以從基類型更改為該類的派生類型
• 用in關鍵字標記逆變形式的類型參數
• 這個參數一般作輸入參數，這個在Predicate、Action中有所體現

　　協變性：方法能返回從委托的返回類型派生的一個類型。

• 泛型類型參數可以從派生類型更改為它的基類型
• 用out關鍵字來標記協變形式的類型參數
• 這個參數一般作為返回值，這個在Func的TResult返回參數有所體現

　　可能有點暈，只要記住逆變是指參數，協變是指返回值；逆變是指基類到派生類，協變是指派生類到基類。

怎么用逆變，協變？

　　泛型委托Predicate、Action和Func都用到了逆變和協變，我們也可以不使用它們自定義一種泛型委托，如下：

        delegate TResult MyDelegate<in T,out TResult>(T obj);
        public void delgateZidingyi()
        {
            var d1 = new MyDelegate<FieldAccessException, object>(delegateMethod6);
            d1(new FieldAccessException());
        }
        static string delegateMethod6(Exception item)
        {
            return "123";
        }

　　其實上面定義的委托類型MyDelegate，也不需要創建那么麻煩，使用Func就可以了，也從中看出泛型委托Predicate、Action和Func只是微軟方便我們創建委托提供的一種方式，我們完全可以自定義，上面也說明了逆變和協變所起到的效果。

　　如果你覺得本篇文章對你有所幫助，請點擊右下部“推薦”，^_^