Delegate、Action、Func、Predicate委托的使用

(1) delegate

• delegate我们常用到的一种声明 
• Delegate至少0个参数，至多32个参数，可以无返回值，也可以指定返回值类型。
• 例：public delegate int MethodtDelegate(int x, int y); 表示有两个参数，并返回int型。

//委托的声明和使用
    delegate double MyDelegate(double param1, double param2);//定义委托相当于定义了一个没有函数体的函数，
//需要有返回值和参数列表，定义完委托只能指向返回值和参数列表一致的函数
    private MyDelegate delegate1;//委托的声明   必需指向一个返回值类型和参数列表类型一致的函数才可以使用
    void Start()
    {
        Test1();
    }
    double Multiply(double param1, double param2)//乘法
    {
        return param1 * param2;
    }
    double Divide(double param1, double param2)//除法
    {
        return param1 / param2;
    }
    void Test()
    {
        delegate1 = Multiply;//委托指向此函数引用   此时就可以把委托当做函数来使用
        Debug.Log(delegate1(1,2));
    }
    void Test1()
    {
        delegate1 = Divide;//委托指向此函数引用   此时就委托相当于此函数来使用
        Debug.Log(delegate1(2,5));
    }

• 委托的实际使用 

//委托的实际使用
    delegate void OnDieDelegate();
    void Start()
    {
        //Play(null);
        Play(ShowDieUI);//委托指向ShowDieUI  
    }
    
    void Play(OnDieDelegate onDie)//主角  委托当做形参传递进去
    {
        Debug.Log("死亡");
        if (onDie!=null)
        {
            onDie();
        }
    }
    void ShowDieUI()
    {
        Debug.Log("返回首页UI");
    }

•  委托的简单应用

//委托的简单使用
    delegate void MyDelegate(string param);//定义委托    
    private MyDelegate de;//声明委托
    void Start()
    {
        Test();
    }
    public void China(string str)
    {
        Debug.Log("中文名字:" + str);
    }

    public void English(string str)
    {
        Debug.Log("English Name:" + str);
    }
    void Test()
    {
        de = China;
        de("curry");
    }

• 委托的运算符操作 

//委托的+=  -= 操作
void Test()
    {
        de = China;
        de += English;
        de("curry");
        //输出结果：中文名字：curry  English Name：curry
        //de与China English创建连接
    }
    
void Test()
    {
        de = China;
        de += English;
        de -= English;
        de("curry");
        //输出结果：中文名字：curry  
        //de切断了与English的连接   此时只与China连接
    }

• 委托的清空

  (1)在类中申明清空委托方法，依次循环去除委托引用。
      public void ClearDelegate()
      {
          while (de!= null)
          {
              de-=de;
          }
      }
  (2)如果在类中没有申明清空委托的方法，我们可以利用GetInvocationList查询出委托引用，然后进行去除。
      void Start()
      {
          if (de!= null)
          {
              System.Delegate[] dels = de.GetInvocationList();
              for (int i = 0; i < dels.Length; i++)
              {
                  de-= dels[i] as MyDelegate;
              }
          }
      }

（2）Action委托 

• Action是一个泛型的委托，其内部即使用delegate去实现，当普通的delegate定义的参数与Action个数、类型一致时，两者实现的功能是一样的。只是Action的方式更加简洁、规范。
• Action是无返回值的泛型委托。
• Action 表示无参，无返回值的委托
• Action<int, string> 表示有传入参数int, string无返回值的委托
• Action<int, string, bool> 表示有传入参数int, string, bool无返回值的委托
• Action<int, int, int, int> 表示有传入4个int型参数，无返回值的委托
• Action至少0个参数，至多16个参数，无返回值。

//Action委托引用了一个void返回类型的方法，T表示方法参数，先看Action委托有哪些，不能用于有返回值的方法
//Action 表示无参，无返回值的委托
//Action <in T >//T为泛型，指的是方法里的参数类型
//Action<int,string> 表示有传入参数int,string无返回值的委托
//Action <in T1,in T2....inT16 >//最多可以放入16个泛型
如果一个方法没有返回值和参数，直接Action一个对象a就可以进行方法的指向
如果一个方法没有返回值但有参数，需要以Action +委托对象名的形式进行委托，且泛型T要与方法的参数类型相同
如果是一个方法的重载，Action可以后面通过泛型去指定action指向的方法的多个参数的类型，参数类型跟Action后的类型相对应
可以使用 Action<T1, T2, T3, T4> 委托以参数形式传递方法，而不用显式声明自定义的委托。 封装的方法必须与此委托定义的
方法签名相对应。 也就是说，封装的方法必须具有四个均通过值传递给它的参数，并且不能返回值。 （在 C# 中，该方法必须返回
 void）通常，这种方法用于执行某个操作。
//需要引入using System命名空间
    void Start()
    {
        Test();
    }
    public void China(string str)
    {
        Debug.Log("中文名字:" + str);
    }

    public void English(string str)
    {
        Debug.Log("English Name:" + str);
    }
    void Test()
    {
        //action是系统预定义的委托类型，可以指向一个没有返回值没有参数的方法
        Action<string> a=China;//定义了一个委托类型，指向一个没有返回值，有一个string参数的方法，<>里是泛型，可自定义
        a("curry");
        a += English;
        a("curry");
    }

（3）Func委托

• Func是有返回值的泛型委托
• Func<int> 表示无参，返回值为int的委托
• Func<object, string, int> 表示传入参数为object, string 返回值为int的委托
• Func<object, string, int> 表示传入参数为object, string 返回值为int的委托
• Func<T1, T2,, T3, int> 表示传入参数为T1, T2,, T3(泛型) 返回值为int的委托
• Func至少0个参数，至多16个参数，根据返回值泛型返回。必须有返回值，不可void

Func是有返回值的泛型委托
Func<int> 表示无参，返回值为int的委托
Func<object,string,int> 表示传入参数为object, string 返回值为int的委托
Func<T1,T2,,T3,int> 表示传入参数为T1,T2,,T3(泛型)返回值为int的委托
Func至少0个参数，至多16个参数，根据返回值泛型返回。必须有返回值，不可void

//需要引入using System命名空间
    void Start()
    {
        Test();
    }
    public string China()
    {
        return "str";
    }

    public string English(string str)
    {
        return str;
    }
    void Test()
    {
        Func<string> a=China;//Func后面可以跟很多类型，最后一个类型是返回值类型，前面的都是参数类型，位置要对应   
        Debug.Log(a());
        Func<string, string> b = English;
        Debug.Log(b("curry"));
    }

（4）predicate的使用

• predicate 是返回bool型的泛型委托
• predicate<int> 表示传入参数为int 返回bool的委托
• Predicate有且只有一个参数，返回值固定为bool
• 例：public delegate bool Predicate<T>(T obj)
• Action可以直接作为无返回值得委托事件的写法。
• Func是有返回值的。
• public delegate void DoDelegate(object parm);
• public DoDelegate DoMethod;
• public Action<object> doAction4OneParm;
• public Action<object, object> doAction4TwoParm;
• Public Func<object, bool> DoFuncOneParam; (返回值是bool)

泛型委托：表示定义一组条件并确定指定对象是否符合这些条件的方法。此委托由 Array 和 List 类的几种方法使用，用于在集合中搜索元素。
//需要引入using System命名空间
    void Start()
    {
        Test();
    }
    static bool test(int temp)
    {
        return temp < 10 ? true : false;
    }
    void Test()
    {
        int[] temps = {5, 10, 15, 20};
        int first = Array.Find(temps, test);
        //使用带有Array.Find方法的Predicate委托搜索int结构的数组。如果temp字段的数值小于10，此委托表示的方法test将返回true。
        //Find方法为temps数组的每个元素调用此委托，在符合测试条件(temps中的值小于10)的第一个点处停止，返回满足的int类型的first
        Debug.Log(first);
    }