簡單的概念，也需要經常看看，

一、前言

先簡單說說Delegate的由來，最早在C/C++中，有一個概念叫函式指標，其實就是一個記憶體指標，指向一個函式，呼叫函式時，只要呼叫函式指標就可以了，至于函式本身的實作，可以放在其它地方，也可以后實作，到了.Net，沒有指標的概念了，但這種方式很實用，所以這個概念也保留了下來，形成了現在的委托Delegate，

另外，在.Net中，也把委托延伸了，與執行回呼設計成了同一種機制，允許開發者定義回呼的簽名和型別，

當我們宣告一個委托時，編譯器會生成一個從MulticastDelegate派生的類，MulticastDelegate還包含幾個方法，不過因為這些方法是CLR運行時動態生成的，代碼IL中看不到，也不需要關心，

委托最大的特性是不需要進行強耦合，所以呼叫者其實并不知道所呼叫的是靜態方法還是實體方法，也不知道具體呼叫的內容，舉個見的例子，UI編程中的按鈕Button類，按鈕類本身并不知道它的OnClick事件是如何處理的，也不需要知道，所以實際中，OnClick事件就是使用委托發布的，開發者在開發程序中實作OnClick事件的處理，并由UI訂閱使用，

這種方式，就是委托對類的解耦，

為了防止不提供原網址的轉載，特在這里加上原文鏈接：https://www.cnblogs.com/tiger-wang/p/14330314.html

二、簡單委托

委托有一個非常簡單的規則，就是：要參考的方法的回傳型別或引數要與委托型別宣告相匹配，

聽著有點繞口，我們拿一個例子來說，

我們有一個方法：

void PrintInfo(string message);

按照規則，這個方法對應的委托方法可以寫成：

void Delegate_PrintInfo(string message);

這樣，按照規則，委托使用時就可以寫成：

Delegate_PrintInfo = PrintInfo;

這樣，當我們呼叫Delegate_PrintInfo("Hello WangPlus")的時候，實際執行的是PrintInfo("Hello WangPlus")了，

下面，我們來看看委托的宣告，

public delegate int Delegate_Method(int x, int y);

委托可以封裝任何方法，在上面這個例子里，我們接受兩個引數，并回傳一個int值，

在這樣一個宣告中，delegate是一個關鍵詞，表明我們宣告的是一個委托，而其它部分，跟我們正常的代碼方式沒有任何區別，

多舉幾個例子看看：

public delegate void Demo_Func1(string para);
public delegate ClassA Demo_Func2(ClassB para);
private delegate StructA Demo_Func3(int para);

除了delegate，其它內容跟正常方法沒有區別，

宣告有了，如何用呢？看例子：

class Program
{
    public delegate int Delegate_Method(int x, int y);

    static void Main(string[] args)
    {
        Delegate_Method handler = SumMethod;
        int result = handler(3, 4);
    }
    static int Sum(int x, int y)
    {
        return x + y;
    }
}

這是一個簡單的例子，

我們先定義了一個委托，接受兩個引數，并回傳int值，我希望這個委托呼叫下面的Sum方法，因此Sum方法和委托Delegate_Method的簽名（引數和回傳值）兼容，這兒要注意理解這個兼容的概念，不是完全相同，是兼容，

再寫個稍微復雜一點的例子：

public delegate void Delegate_Method(int x, int y);

class ExampleClass
{
    public void Sum(int x, int y)
    {
        Console.WriteLine(x + y);
    }
    public void Sub(int x, int y)
    {
        Console.WriteLine(x - y);
    }
}
class Program
{
    static void Main(string[] args)
    {
        ExampleClass example = new ExampleClass();
        Delegate_Method delegate_1;
        Delegate_Method delegate_2;

        delegate_1 = example.Sum;
        delegate_2 = example.Sub;

        delegate_1(100, 50);
        delegate_2(100, 50);
    }
}

如果第一個例子明白了，那這個例子也不難理解，

三、委托鏈

委托鏈的核心的維護一個可呼叫的委托串列，當呼叫串列時，串列中的所有委托都會被呼叫，同時，委托鏈可以使用運算子，用+來組合，用-來洗掉，

看例子：

public delegate void Delegate_Method(int x, int y);

class ExampleClass
{
    public void Sum(int x, int y)
    {
        Console.WriteLine(x + y);
    }
    public void Sub(int x, int y)
    {
        Console.WriteLine(x - y);
    }
}
class Program
{
    static void Main(string[] args)
    {
        ExampleClass example = new ExampleClass();
        Delegate_Method[] delegate_list = new Delegate_Method[] { example.Sum, example.Sub };
        Delegate_Method delegate_chain = delegate_list[0] + delegate_list[1];

        delegate_chain(100, 50);
    }
}

在這個例子中，定義了一個委托陣列，然后用+運算子組合這些方法，

Delegate_Method delegate_chain = delegate_list[0] + delegate_list[1];  
Delegate_Method delegate_chain1 = delegate_chain - delegate_list[0];

上面兩行代碼，CLR將解釋為(Sum + Sub) - Sum，并只執行Sub方法，這是一個使用-運算子從委托鏈中移除委托的例子，

您還可以遍歷委托鏈：

public delegate void Delegate_Method(int x, int y);

class ExampleClass
{
    public void Sum(int x, int y)
    {
        Console.WriteLine(x + y);
    }
    public void Sub(int x, int y)
    {
        Console.WriteLine(x - y);
    }
}
class Program
{
    static void Main(string[] args)
    {
        ExampleClass example = new ExampleClass();
        Delegate_Method[] delegate_list = new Delegate_Method[] { example.Sum, example.Sub };
        Delegate_Method delegate_chain = delegate_list[0] + delegate_list[1];

        Delegate[] delegates = delegate_chain.GetInvocationList();
        for (int i = 0; i < delegates.Length; i++)
        {
            Delegate_Method _delegate = (Delegate_Method)delegates[i];
            _delegate(100, 50);
        }
    }
}

在這個例子中，使用了GetInvocationList方法獲取委托鏈中的所有委托，這個方法幫助我們參考委托鏈中的每個委托，我們也可以從委托鏈中以任何順序呼叫委托，

四、多播委托

委托在被呼叫時可以呼叫多個方法，這稱之為多播，委托物件的一個非常有用的屬性是，它們可以被分配給一個委托實體，以便使用+/-運算子進行多播，組合委托呼叫由它組成的多個委托，

多播委托時，只能組合相同型別的委托，運算子可用于從組合委托中增加/洗掉委托組件，

此外，多播委托回傳型別總是void，

class Program
{
    public delegate void Delegate_Method(int x, int y);

    public static void Sum(int i, int j)
    {
        Console.WriteLine(i + j);
    }
    public static void Sub(int i, int j)
    {
        Console.WriteLine(i - j);
    }

    static void Main(string[] args)
    {
        Delegate_Method delegate1, delegate2, delegate3, delegate4;

        delegate1 = Sum;
        delegate2 = Sub;

        delegate3 = delegate1 + delegate2;
        delegate3(100, 50);

        delegate4 = delegate3 - delegate2;
        delegate4(100, 50);
    }
}

這段代碼里，delegate3 = delegate1 + delegate2;等同于挨個呼叫Sum和Sub；delegate4 = delegate3 - delegate2;等同于呼叫(Sum + Sub) - Sub，實際最后呼叫的是Sum，

五、結論

委托在Dotnet里，是一個很常用的代碼組成，用好委托，可以很漂亮地實作諸如事件、回呼等操作，所以必須要熟練，

最后再說一下委托的基本內容：

委托是面向物件的操作，型別安全，資料安全；
委托派生自Dotnet的Delegate類，它是一個類；
委托型別是密封（sealed）的，所以不能從委托繼承，
?

微信公眾號：老王Plus

掃描二維碼，關注個人公眾號，可以第一時間得到最新的個人文章和內容推送

本文著作權歸作者所有，轉載請保留此宣告和原文鏈接

轉載請註明出處，本文鏈接：https://www.uj5u.com/net/253310.html

標籤：.NET Core

上一篇：【翻譯】- ASP.NET Core 中的記憶體管理和模式

下一篇：RestSharp?.net REST/HTTP 工具庫

一文說通Dotnet的委托

一、前言

二、簡單委托

三、委托鏈

四、多播委托

五、結論