C# 從1到Core--委託與事件

FlyLolo 發表於 2020-06-30
C#

  委託與事件在C#1.0的時候就有了,隨著C#版本的不斷更新,有些寫法和功能也在不斷改變。本文溫故一下這些改變,以及在NET Core中關於事件的一點改變。

一、C#1.0 從委託開始

1. 基本方式

  什麼是委託,就不說概念了,用例子說話。

  某HR說他需要招聘一個6年 .NET5 研發經驗的“高階”工程師,他想找人(委託)別人把這條招聘訊息發出去。這樣的HR很多,所以大家定義了一個通用的發訊息規則:

public delegate string SendDelegate(string message);

  這就像一個介面的方法,沒有實際的實現程式碼,只是定義了這個方法有一個string的引數和返回值。所有想發招聘訊息的HR只要遵守這樣的規則即可。

委託本質上是一個類,所以它可以被定義在其他類的內部或外部,根據實際引用關係考慮即可。本例單獨定義在外部。

為HR定義了一個名為HR的類:

public class HR
{
    public SendDelegate sendDelegate;
    public void SendMessage(string msg)
    {
        sendDelegate(msg);
    }
}

  HR有一個SendDelegate型別的成員,當它需要傳送訊息(SendMessage)的時候,只需要呼叫這個sendDelegate方法即可。而不需要實現這個方法,也不需要關心這個方法是怎麼實現的。

當知道這個HR需要傳送訊息的時候,獵頭張三接了這個幫忙招人的工作。獵頭的類為Sender,他有一個用於傳送訊息的方法Send,該方法恰好符合眾人定義的名為SendDelegate的發訊息規則。這有點像實現了一個介面方法,但這裡不要求方法名一致,只是要求方法的簽名一致。

public class Sender
{
    public Sender(string name)
    {
        this.senderName = name;
    }

    private readonly string senderName;
    public string Send(string message)
    {
        string serialNumber = Guid.NewGuid().ToString();
        Console.WriteLine(senderName + " sending....");
        Thread.Sleep(2000);
        Console.WriteLine("Sender: " + senderName + " , Content: " + message + ", Serial Number: "  + serialNumber);
        return serialNumber;
    }
}

獵頭幫助HR招人的邏輯如下:

public void Test()
{
    //一個HR
    HR hr = new HR();

    //獵頭張三來監聽,聽到HR發什麼訊息後立刻傳播出去
    Sender senderZS = new Sender("張三");
    hr.sendDelegate = senderZS.Send;

//HR遞交訊息 hr.SendMessage("Hello World"); }

獵頭將自己的發訊息方法“賦值”給了HR的SendDelegate方法,為什麼可以“賦值”? 因為二者都遵守SendDelegate規則。 就像A和B兩個變數都是int型別的時候,A可以賦值給B一樣。

這就是一個簡單的委託過程,HR將招人的工作委託給了獵頭,自己不用去做招人的工作。

但經常一個招聘工作經常會有多個獵頭接單,那就有了多播委託。

2. 多播委託

 看一下下面的程式碼:

public void Test()
{
    //一個HR
    HR hr = new HR();

    //獵頭張三來監聽,聽到HR發什麼訊息後立刻傳播出去
    Sender senderZS = new Sender("張三");
    hr.sendDelegate = senderZS.Send;

    //快嘴李四也來了
    Sender senderLS = new Sender("李四");
    hr.sendDelegate += senderLS.Send;
//HR遞交訊息 hr.SendMessage("Hello World"); }

與之前的程式碼改變不大, 只是新增了李四的方法繫結,這樣HR發訊息的時候,張三和李四都會發出招人的訊息。

這裡要注意李四繫結方法的時候,用的是+=而不是=,就像拼接字串一樣,是拼接而不是賦值,否則會覆蓋掉之前張三的方法繫結。

對於第一個繫結的張三,可以用=號也可以用+=(記得之前好像第一個必須用=,實驗了一下現在二者皆可)。

這同時也暴露了一些問題:

  • 如果後面的獵頭接單的時候不小心(故意)用了=號, 那麼最終前面的人的繫結都沒有了,那麼他將獨佔這個HR客戶,HR發出的訊息只有他能收到。
  • 可以偷偷的呼叫獵頭的hr.sendDelegate
public void Test()
{
    //一個HR
    HR hr = new HR();

    //大嘴張三來監聽,聽到HR發什麼訊息後立刻傳播出去
    Sender senderZS = new Sender("張三");
    //hr.sendDelegate -= senderZS.Send; //即使未進行過+=  直接呼叫-=,也不會報錯
    hr.sendDelegate += senderZS.Send;

    //快嘴李四也來了
    Sender senderLS = new Sender("李四");
    hr.sendDelegate += senderLS.Send;

    //移除
    //hr.sendDelegate -= senderZS.Send;

    //風險:注意上面用的符號是+=和-=   如果使用=,則是賦值操作,
    //例如下面的語句會覆蓋掉之前所有的繫結
    //hr.sendDelegate = senderWW.Send;

    //HR遞交訊息
    hr.SendMessage("Hello World");

    //風險:可以偷偷的以HR的名義偷偷的發了一條訊息    sendDelegate應該只能由HR呼叫   
    hr.sendDelegate("偷偷的發一條");

}

3. 通過方法避免風險

  很自然想到採用類似Get和Set的方式避免上面的問題。既然委託可以像變數一樣賦值,那麼也可以通過引數來傳值,將一個方法作為引數傳遞。

 

    public class HRWithAddRemove
    {
        private SendDelegate sendDelegate;

        public void AddDelegate(SendDelegate sendDelegate)
        {
            this.sendDelegate += sendDelegate; //如果需要限制最多繫結一個,此處可以用=號
        }

        public void RomoveDelegate(SendDelegate sendDelegate)
        {
            this.sendDelegate -= sendDelegate;
        }

        public void SendMessage(string msg)
        {
            sendDelegate(msg);
        }
    }

經過改造後的HR,SendDelegate方法被設定為了private,之後只能通過Add和Remove的方法進行方法繫結。

4.模擬多播委託機制

通過上面委託的表現來看,委託就像是儲存了一個相同方法名的集合 List<SendDelegate> ,可以向集合中新增或移除方法,當呼叫這個委託的時候,會逐一呼叫該集合中的各個方法。

例如下面的程式碼( 注意這裡假設SendDelegate只對應一個方法 ):

public class HR1
{
    public void Delegate(SendDelegate sendDelegate)
    {
        sendDelegateList = new List<SendDelegate> { sendDelegate }; //對應=
    }

    public void AddDelegate(SendDelegate sendDelegate)
    {
        sendDelegateList.Add(sendDelegate); //對應+=
    }

    public void RomoveDelegate(SendDelegate sendDelegate)
    {
        sendDelegateList.Remove(sendDelegate);//對應-=
    }

    public List<SendDelegate> sendDelegateList;

    public void SendMessage(string msg)
    {
        foreach (var item in sendDelegateList)
        {
            item(msg);
        }
    }
}

二、C#1.0 引入事件

  1.簡單事件

  如果既想使用-=和+=的方便,又想避免相關功能開閉的風險怎麼辦呢?可以使用事件:

    public class HRWithEvent
    {
        public event SendDelegate sendDelegate;
        public void SendMessage(string msg)
        {
            sendDelegate(msg);
        }
    }

  只是將SendDelegate前面新增了一個event標識,雖然它被設定為public,但如下程式碼卻會給出錯誤提示: 事件“HRWithEvent.sendDelegate”只能出現在 += 或 -= 的左邊(從型別“HRWithEvent”中使用時除外) 

 hr.sendDelegate = senderZS.Send;
 hr.sendDelegate("偷偷的發一條");

  2.事件的訪問器模式

   上文為委託定義了Add和Remove方法,而事件支援這樣的訪問器模式,例如如下程式碼:

    public class CustomerWithEventAddRemove
    {
        private event SendDelegate sendDelegate;

        public event SendDelegate SendDelegate
        {
            add { sendDelegate += value; }
            remove { sendDelegate -= value; }
        }
        public void SendMessage(string msg)
        {
            sendDelegate(msg);
        }
    }

 

  可以像使用Get和Set方法一樣,對事件的繫結與移除進行條件約束。 

  3. 控制繫結事件的執行

  當多個委託被繫結到事件之後,如果想精確控制各個委託的執行怎麼辦,比如返回值(雖然經常為void)、異常處理等。

第一章第4節通過一個List<SendDelegate> 模擬了多播委託的繫結。 會想到如果真能迴圈呼叫一個個已繫結的委託,就可以精確的進行控制了。那麼這裡說一下這樣的方法:

 

    public class HRWithEvent
    {
        public event SendDelegate sendDelegate;
        public void SendMessage(string msg)
        {
            //sendDelegate(msg);  此處不再一次性呼叫所有
            if (sendDelegate != null)
            {
                Delegate[] delegates = sendDelegate.GetInvocationList(); //獲取所有已繫結的委託
                foreach (var item in delegates)
                {
                    ((SendDelegate)item).Invoke(msg); //逐一呼叫
                }
            }

        }
    }

  這裡通過Invoke方法逐一呼叫各個Delegate,從而實現對每一個Delegate的呼叫的控制。若需要非同步呼叫,則可以通過BeginInvoke方法實現(.NET Core之後不再支援此方法,後面會介紹。)

((SendDelegate)item).BeginInvoke(msg,null,null);

  4. 標準的事件寫法

  .NET 事件委託的標準簽名是:

void OnEventRaised(object sender, EventArgs args);

 

  返回型別為 void。 事件基於委託,而且是多播委託。 引數列表包含兩種引數:發件人和事件引數。 sender 的編譯時型別為 System.Object

  第二種引數通常是派生自 System.EventArgs 的型別.NET Core 中已不強制要求繼承自System.EventArgs,後面會說到)

  將上面的例子修改一下,改成標準寫法,大概是下面程式碼的樣子:

public class HRWithEventStandard
{
    public delegate void SendEventHandler(object sender, SendMsgArgs e);
    public event SendEventHandler Send;
    public void SendMessage(string msg)
    {
        var arg = new SendMsgArgs(msg);
        Send(this,arg); //arg.CancelRequested 為最後一個的值   因為覆蓋
    }
}

public class SendMsgArgs : EventArgs
{
    public readonly string Msg = string.Empty;
    public bool CancelRequested { get; set; }
    public SendMsgArgs(string msg)
    {
        this.Msg = msg;
    }
}

 

 

三、隨著C#版本改變

1. C#2.0 泛型委託

  C#2.0 的時候,隨著泛型出現,支援了泛型委託,例如,在委託的簽名中可以使用泛型,例如下面程式碼

public delegate string SendDelegate<T>(T message);

這樣的委託適用於不同的引數型別,例如如下程式碼(注意使用的時候要對應具體的型別)

public delegate string SendDelegate<T>(T message);

public class HR1
{
    public SendDelegate<string> sendDelegate1;
    public SendDelegate<int> sendDelegate2;
    public SendDelegate<DateTime> sendDelegate3;
}

public static class Sender1
{
    public static string Send1(string msg)
    {
        return "";
    }

    public static string Send2(int msg)
    {
        return "";
    }
}
    
public class Test
{
    public void TestDemo()
    {
        HR1 hr1 = new HR1();
        hr1.sendDelegate1 = Sender1.Send1; // 注意使用的時候要對應具體的型別
        hr1.sendDelegate2 = new SendDelegate<int>(Sender1.Send2);
        hr1.sendDelegate3 = delegate (DateTime dateTime) { return dateTime.ToLongDateString(); };

    }
}

2. C#2.0 delegate運算子

delegate 運算子建立一個可以轉換為委託型別的匿名方法:

例如上例中這樣的程式碼:

hr1.sendDelegate3 = delegate (DateTime dateTime) { return dateTime.ToLongDateString(); };

3. C#3.0 Lambda 表示式

從 C# 3 開始,lambda 表示式提供了一種更簡潔和富有表現力的方式來建立匿名函式。 使用 => 運算子構造 lambda 表示式,

例如“delegate運算子”的例子可以簡化為如下程式碼:

hr1.sendDelegate3 = (dateTime) => { return dateTime.ToLongDateString(); };

 

4.C#3,NET Framework3.5,Action 、Func、Predicate

Action 、Func、Predicate本質上是框架為我們預定義的委託,在上面的例子中,我們使用委託的時候,首先要定義一個委託型別,然後在實際使用的地方使用,而使用委託只要求方法名相同,在泛型委託出現之後,“定義委託”這一操作就顯得越來越累贅,為此,系統為我們預定義了一系列的委託,我們只要使用即可。

例如Action的程式碼如下:

    public delegate void Action();
    public delegate void Action<in T>(T obj);
    public delegate void Action<in T1, in T2>(T1 arg1, T2 arg2);
    public delegate void Action<in T1, in T2, in T3>(T1 arg1, T2 arg2, T3 arg3);
    public delegate void Action<in T1, in T2, in T3, in T4>(T1 arg1, T2 arg2, T3 arg3, T4 arg4);
    public delegate void Action<in T1, in T2, in T3, in T4, in T5>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5);
    public delegate void Action<in T1, in T2, in T3, in T4, in T5, in T6>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6);
    public delegate void Action<in T1, in T2, in T3, in T4, in T5, in T6, in T7>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7);
    public delegate void Action<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8);
    public delegate void Action<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, in T9>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9);
    public delegate void Action<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, in T9, in T10>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10);
    public delegate void Action<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, in T9, in T10, in T11>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11);
    public delegate void Action<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, in T9, in T10, in T11, in T12>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12);
    public delegate void Action<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, in T9, in T10, in T11, in T12, in T13>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13);
    public delegate void Action<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, in T9, in T10, in T11, in T12, in T13, in T14>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14);
    public delegate void Action<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, in T9, in T10, in T11, in T12, in T13, in T14, in T15>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15);
    public delegate void Action<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, in T9, in T10, in T11, in T12, in T13, in T14, in T15, in T16>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15, T16 arg16);

實際上定義了最多16個引數的無返回值的委託。

Func與此類似,是最多16個引數的有返回值的委託。Predicate則是固定一個引數以及bool型別返回值的委託。

public delegate bool Predicate<T>(T obj);

 5. .NET Core 非同步呼叫

第2.3節中,提示如下程式碼在.NET Core中已不支援

((SendDelegate)item).BeginInvoke(msg,null,null);

 

會丟擲異常:

System.PlatformNotSupportedException:“Operation is not supported on this platform.”

 

需要非同步呼叫的時候可以採用如下寫法:

Task task = Task.Run(() => ((SendDelegate)item).Invoke(msg));

 

對應的 EndInvoke() 則改為: task.Wait(); 

 

 5. .NET Core的 EventHandler<TEventArgs>

.NET Core 版本中,EventHandler<TEventArgs> 定義不再要求 TEventArgs 必須是派生自 System.EventArgs 的類, 使我們使用起來更為靈活。

例如我們可以有這樣的寫法:

EventHandler<string> SendNew

 

這在以前的版本中是不允許的。