声明一个委托

//声明一个委托，指定该委托的每个实例都包含一个方法的引用，方法必须带有一个Int参数，并返回Void
delegate void Add(int x);
//定义委托基本上是定义一个新类，所以可以再定义类的任何相同地方定义委托，可以添加Public,Private,Protected等
 delegate string GetString();

//委托的特征
//委托的类型是安全的，可以确保被调用的方法的签名是正确的，静态方法和实例方法都可以注册进委托

public class Test : MonoBehaviour
{
    private void Start()
    {
        int x=40;
        //委托在语法中总是接收一个参数的构造函数，这个参数就是属于引用类型的方法，这个方法必须匹配最初定义委托时的签名
        GetString mod = new GetString(x.ToString);
        GetString mod2 = new GetString(Go);
        //为了减少输入量，在需要委托实例的每个位置可以只传送地址的名称。只要编译器可以把委托实例解析为
        //特定类型，这个c#特性就是有效的，x.toString就是方法的地址
        GetString mod3 = x.ToString;
        print(mod());
        print(mod2());
        print(mod3());
    }
    public string Go()
    {
        return "3";
    }

简单的委托示例

class  Math
{
    public static double Mul(double value) => value * 2;
    public static double Square(double value) => value * value;
}
//定义一个委托
delegate double GetNum(double d);
public class Test : MonoBehaviour
{
    private GetNum[] nums =
    {
        Math.Mul,
        Math.Square
    };

    private void Start()
    {
        for (int i = 0; i < nums.Length; i++)
        {
            DisposeNum(nums[i], 10);
        }
    }


    static void DisposeNum(GetNum action, double value)
    {
        double result = action(value);
        print(result);
    }

Action和Func委托

 //Action表示引用一个Void返回类型的方法
     Action<int> _action; 
     Action<int, string, float> _action1;
     //允许调用带返回类型的方法
     private Func<int> _func; //不带参数返回Int的方法
     private Func<string, string, int> _func2; //带两个string参数，返回Int的方法
     private void Start()
     {
          _func = Go;
     }
     int Go()
     {
          return 1;
     }

多播委托，（连续播放委托，中途一个委托出错会导致不在继续播放，需要另一种写法）

  private Action go;

     private void Start()
     {
          go += One;
          go += Two;
          //go();  //直接调用，只会调用第一个方法，然后由于抛出错误，委托迭代中断
          Delegate[] des = go.GetInvocationList();   //打断连播，还会继续执行接下来的委托
          foreach (Action item in des)
          {
               try
               {
                    item();
               }
               catch (Exception e)
               {
                    Console.WriteLine(e);
               }
          }
     }

     public void One()
     {
          Debug.Log("One");
          throw new Exception("Error in one");
     }
     public void Two()
     {
          Debug.Log("Two");
     }