1. 委托的定義和使用

• 委托的作用：如果要把方法作為函數來進行傳遞的話，就要用到委托。委托是一個類型，這個類型可以賦值一個方法的引用。C#的委托 通過 delegate 關鍵字來聲明。
• 聲明委托的方式：
  // 第一種方式
  delegate void MyDelegate_1(int x);
  // 第二種方式
  delegate void MyDelegate_2<T>(T x);
• 使用委托的方式：
  // 第一種方式
  MyDelegate_1 mydelegate = new MyDelegate_1( func );
  // 第二種方式
  MyDelegate_1 mydelegate = func;

委托調用方法
// 例子
public class Delegate : MonoBehaviour
{
 public delegate void ShowDelegate();
 public delegate double MultiplyDelegate(double x, double y);
 void Start()
    {
 ShowDelegate show = new ShowDelegate(Show_1);
 MultiplyDelegate mul = Multiply;
 // 直接調用
 show();
 Debug.Log(mul(2f, 3f));
 // 調用invoke方法
 show.Invoke();
 Debug.Log(mul.Invoke(2f, 3f));
    }
 public void Show_1()
    {
 Debug.Log("Show1");
    }
 public double Multiply(double x, double y)
    {
 return x * y;
    }
}

2. 系統內置Action委托

Action委托：

• Action<T>
  是 .NET Framework 內置的泛型委托，可以使用 Action<T>委托以參數形式傳遞方法，而不用顯式聲明自定義的委托。
• 封裝的方法必須與此委托定義的方法簽名相對應。即 封裝的方法必須具有一個通過值傳遞給它的參數，并且不能有返回值。 還有一種是非泛型委托 Action。

注意：

• Action
  委托至少 0 個參數，至多 16 個參數，無返回值；
• Action
  表示無參，無返回值的委托；
• Action<int, string>
  表示有傳入參數int，string無返回值的委托；
• Action<int, string, bool>
  表示有傳入參數int，string，bool無返回值的委托；
• Action<int, int, int, int>
  表示有傳入4個int型參數，無返回值的委托。

// 案例
// 使用Action、Func等委托時，需要添加 using System;
public class SystemAction : MonoBehaviour
{
    void Start()
    {
        // 無參
        Action action_1 = Show_1;
        action_1();

        // 帶參
        Action<int, int> action_2 = Show_2;
        action_2(1, 2);

    }
    void Show_1()
    {
        Debug.Log("Show_1");
    }
    void Show_2(int a, int b)
    {
        Debug.Log("Show_2 " + (a + b));
    }
}

3. 系統內置Func委托

Func委托：Func是 .NET Framework 內置的帶有返回類型的泛型委托。

注意：

• Func
  至少 0 個輸入參數，至多 16 個輸入參數，根據返回值泛型返回。必須有返回值，不可用void；
• Func<int>
  表示沒有輸入參數，返回值為int類型的委托；
• Func<object, string, int>
  表示傳入參數為object，string，返回值類型為int的委托；
• Func<T1, T2, T3, int>
  表示傳入參數為T1, T2, T3（泛型），返回值為int類型的委托。

/**
 * System.Func 可以不帶參數，但是必須帶一個返回值
 * System.Func 若是調用的多個泛型的委托定義，最后參數的數據類型是函數的返回值類型，需要保持一致；
 * 非最后一個泛型的聲明，需要與實現函數的參數個數及類型保持一致
 */
public class SystemFunc : MonoBehaviour
{
    void Start()
    {
        // 不帶參數，返回值為string類型
        Func<string> func_1 = Show_1;
        string a = func_1();
        Debug.Log(a);
        // 帶int類型參數，返回值為string類型
        Func<int, string> func_2 = Show_2;
        string b = func_2(100);
        Debug.Log(b);
        // 拋出異常FormatException: Input string was not in a correct format.
        /*Func<string, int > func_3 = Show_3;
        int c = func_3("s");
        Debug.Log(c);*/
    }
    string Show_1()
    {
        return "Show_1";
    }
    String Show_2(int a)
    {
        return a.ToString();
    }
    int Show_3(string x)
    {
        return int.Parse(x);
    }
}

4. 匿名方法、event事件、多播委托

匿名方法：沒有名字的方法稱之為匿名方法。

Event事件：Event事件本身就是一種委托，只是該委托只能作為類的成員，且不可在類外進行調用。

多播委托：在 C# 語言中，多播委托是指在一個委托中注冊多個方法，在注冊方法時可以在委托中使用加號運算符或者減號運算符來實現添加或撤銷方法。

/**
 * 1. 匿名事件
 * 2. event事件
 * （1）event事件 只允許作為類的成員變量，且僅在類的內部使用才可以，外部不得直接調用
 * （2）當作為一個類的成員，event事件在外部類賦值時，只能通過 +=/-= 的方式；而對于普通的Action則可以 =/+=/-=的方式進行賦值
 * （3）可通過在類中定義方法調用event事件，外部類間接地調用這個方法來調用event
 * 3. 多播委托 += -=
 * 委托屬于引用類型，引用類型的默認值為null，直接使用會報空異常；
 * 故在使用之前需要先判斷委托對象（引用對象）是否為空
 */
public class MyEventClass
{
    public event Action action_3;
    public Action action_4;

    // event事件調用
    public void Send()
    {
        if(action_3 != null)
        {
            action_3();
        }
    }
}

public class Broadcast : MonoBehaviour
{
    // event事件
    event Action action_2;

    void Start()
    {
        // Action action = Show_1; 將該語句轉為匿名
        Action action = delegate ()  // 匿名函數
        {
            Debug.Log("匿名函數被執行");
        };
        action();
        // 多播委托
        Action action_1 = Show_1;
        action_1 += Show_2;
        //action_1 -= Show_2;
        //action_1 -= Show_1;
        if (action != null)
        {
            action_1();
        }

        action_2 = Show_1;
        action_2();

        MyEventClass mEvent = new MyEventClass();
        mEvent.action_3 += Show_2;
        mEvent.Send();
        mEvent.action_4 = Show_2;
        mEvent.action_4();
    }
    void Show_1()
    {
        Debug.Log("Show_1被執行");
    } 
    void Show_2()
    {
        Debug.Log("Show_2被執行");
    }
}