关于unity中的委托的学习

• 笔者因为需要写一个订阅者模式的信息框架，所以就从头开始学习了   学习的第一步关于委托 其实就是C#中的委托   
• 给大家一个提醒 就是委托分为4种不同的类型   你自己写对应的函数一定跟下面的对应清楚！！！ 选择哪一种取决你需要被委托的函数是哪一种

  	//不带返回值的委托函数 且不带入参
  	delegate void getNumadd1 ();
  	//带返回值的委托函数 且带返回值 返回值是string型
  	delegate string getNumadd ();
  	//带入参的委托函数  且不带返回函数
  	delegate void getNumadd2(int x);
  	//带入参 且 带返回值的委托函数 
  	delegate int getNumadd3(string x);

   

• using System.Collections;
  using System.Collections.Generic;
  using UnityEngine;
  using System.Collections;
  using UnityEngine.Events;
  using System;
  public class DingYe : MonoBehaviour {
  
  
  
  
  	//不带返回值的委托函数 且不带入参
  	delegate void getNumadd1 ();
  	//带返回值的委托函数 且带返回值 返回值是string型
  	delegate string getNumadd ();
  	//带入参的委托函数 这里的入函数类型要与被委托函数的一样都是int 但是函数的名字叫什么无所谓 可以与被委托函数的名字一样 也可以不一样
  	delegate void getNumadd2(int x);
  	//带入参 且 带返回值的委托函数 
  	delegate int getNumadd3(string x);
  
  	string  getNumto(){
  		int a = 1;
  		int b = 2;
  		Debug.Log ("我是a+b=" + (a + b)+"的函数");
  		return (a + b).ToString ();
  	} 
  
  
  	void getNem1(){
  		Debug.Log ("我并不带有任何参数的函数");
  	}
  
  	void getNum2(int a){
  		Debug.Log ("被传入的参数是=" + a);
  	}
  
  	int getNum3(string a){
  		Debug.Log ("我是带入参带返回值的函数参数是=" + a);
  		return int.Parse(a);
  	}
  
  
  
  	// Use this for initialization
  	void Start () {
  		//不带返回值的委托函数
  		Debug.Log("---------下面是不带返回值的委托函数de使用-----------------");
  		getNumadd1 num1=new getNumadd1(getNem1);
  		//使用此委托函数
  		num1 ();
  
  
  
  		//带返回值的委托函数
  		Debug.Log("---------下面是带返回值的委托函数de使用-----------------");
  		getNumadd num = new getNumadd(getNumto);
  		Debug.Log ("我是带有返回参数的委托 返回的值=" + num ());
  
  
  
  		//带入参的委托函数
  		Debug.Log("---------下面是带入参的委托函数de使用-----------------");
  		getNumadd2 num2= new getNumadd2 (getNum2);
  		getNum2 (2);
  
  		//带返回值带入参的返回的函数
  		Debug.Log("---------下面是带返回值带入参的返回的函数de使用-----------------");
  		getNumadd3 num3=new getNumadd3(getNum3);
  
  		Debug.Log( "我是单返回参数带委托的函数返回的是的类型是=string" +"这个参数的值是="+getNum3("3"));
  
  
  
  
  		//开始函数调用函数  定义构造函数 就是是委托函数  方式1
  		FUNCTION func0=new FUNCTION (function1);
  		Print (func0);
  
  		//方式2
  		FUNCTION func1=function2;
  		Print (func1);
  
  
  
  
  		//关于action 的委托是  要求是一个的 一个没有入参 一个没有返回的函数
  		Debug.Log("---------下面的action的使用-----------------");
  		UnityAction afunc2 =  function1;
  		UnityAction afunc3 =  function2;
  		afunc2 ();
  		afunc3 ();
  		//其实action 也是hi可以指向一个带有参数的函数比如   其中入参最多有几个还没有测试  F12过去看到的是4个入参
  		UnityAction<int> afun4 =function3;
  		afun4 (3);
  
  		UnityAction<int,string> afun5 =function3;
  		afun5 (5, "6");
  
  
  		//关于func的使用
  		Debug.Log("---------下面的func的使用-----------------");
  		Func<string> fun1 =  function4;
  		fun1 ();
  		Debug.Log ("我测试的是Func的是使用返回值是=" + fun1);
  		//同时可以返回与入参  第一个入参 第二个是返回参数
  		Func<int ,string>fun2 = function5;
  		int fun2_r = 5;
  		fun2 (fun2_r);
  		Debug.Log ("玩家当前的委托函数返回参数是=" + fun2 (fun2_r) + "入参是=" + fun2_r);
  		//有多个入参函数 因为c#中的返回函数一个  左后一个入参是返回值。之前的都是入参
  		Func<string,int,string>fun3 = function6;
  		string fun3_str="5";
  		int fun3_int = 4;
  		fun3 (fun3_str,fun3_int);
  		Debug.Log ("我测试的是两个入参 第一个参数=" + fun3_str + "string 型 第二个参数= " + fun3_int + "int 型" + "返回的是之前两个参数的和 int 型=" + fun3 (fun3_str, fun3_int));
  	
  	
  		//多播委托
  		Debug.Log("---------下面的是多播委托-----------------");
  		UnityAction allfun= function1;
  		allfun += function2;
  		if (allfun != null)  
  			allfun ();
  //		allfun -= function2;
  //		if (allfun != null) 
  //			allfun ();
  
  
  		//---读取多波委托中的相关参数
  		Debug.Log("---下面的是多播委托的遍历---");
  		if (allfun != null){
  			Delegate[] delegates=allfun.GetInvocationList();
  			foreach (Delegate item in delegates) {
  				item.DynamicInvoke ();
  			}
  		}
  
  	
  
  
  		//匿名函数
  		Debug.Log("---------下面的是匿名函数-----------------");
  		//匿名方法本质上是一个方法，只是没有名字，任何使用委托变量的地方都可以是用匿名方法
  		Func<int,int,string> funcNiMi = delegate(int v1, int v2) {
  			Debug.Log("匿名函数的学习");
  			return (v1 + v2).ToString ();
  		};
  
  
  		//下面关于lambda的学习全部是出现了带有返回参数的委托函数
  		Debug.Log("---------下面的是lambda-----------------");
  		//lambda表达式的方式书写 匿名函数
  		Func<int,string,int> funcNiMin1 =( (int arg1, string arg2) => {
  			return arg1 + int.Parse (arg2);
  		});
  		Debug.Log ("当前的lambda表达式的返回书写结果是==" + funcNiMin1 (10,"15"));
  
  		Func<int,int,int> funcNiMin2 = (arg1, arg2) => {
  			return arg1 * arg2;
  		};
  		Debug.Log ("当前的lambda表达式的返回书写结果是==" + funcNiMin2 (10,15));
  
  		//当委托函数的返回值是只有一个参数同时 可以去掉（）  档{}中的方法只有一个句话的时候也可以直接写上这这句话 它会自动返回这个值 
  		Func<int,int> funcNiMin3 = a => a+1;
  		//上面的与下面的写法同样   
  		Func<int,int> funcNiMin4 = a => {
  			return a + 1;
  		};
  		Func<int,int> funcNiMin5 = (a) => {
  			return a + 1;
  		};
  		Debug.Log ("当前的lambda表达式的返回书写结果是==" + funcNiMin3(3));
  		Debug.Log ("当前的lambda表达式的返回书写结果是==" + funcNiMin4(4));
  		Debug.Log ("当前的lambda表达式的返回书写结果是==" + funcNiMin5(5));
  
  	}
  
  	//使用为函数去调用委托 定义一个函数委托
  	delegate void FUNCTION();
  	void Print(FUNCTION function){ //函数的入参是就是这个这个委托函数
  		Debug.Log ("使用的是Print来调取函数  被调取的函数内容如下");
  		function ();
  
  	}
  
  	void function1(){
  		Debug.Log ("我是函数function1");
  	}
  	void function2(){
  		Debug.Log ("我是函数function2");
  	}
  	void function3(int a){
  		Debug.Log ("我是函数function3  我的参数是="+a);
  	}
  	void function3(int a,string b){
  		Debug.Log ("我是函数function3  我的参数是="+a+b);
  	}
  	string function4(){
  		Debug.Log("待返回参数的函数");
  		return "5" ;
  	}
  	string function5(int a){
  		Debug.Log ("我是有入参同时还有返回的函数  入参与返回参数是="+a);
  		return a.ToString();
  	}
  	string function6(string a,int b){
  		Debug.Log ("我是有入参同时还有返回的函数  入参与返回参数是="+(b+(int.Parse(a))));
  		return a.ToString();
  	}
  
  	// Update is called once per frame
  	void Update () {
  		
  	}
  }