Unity&C#的委托事件总结

1、匿名委托

2、Lambda表达式

using UnityEngine;
using System;//EventArgs需要
using UnityEngine.Events;//Unity事件需要
using UnityEngine.UI;//展示注册已有的UI事件
public class Mom : MonoBehaviour {
//本代码是以总结顺序写的，声明-定义-注册-调用。
//用法1：一个对象可以一口气执行多个方法，并且可顺序执行其他类的方法，用于监听-执行
//1.声明一个C#委托协定，指定方法签名
public delegate int MyDelegate(int i, int j);
//委托也是一个类型，需要声明对象
MyDelegate myDelegate;
//2.C#事件的声明：event+委托+事件名
public event MyDelegate CSharpEvent;
//事件就是一个委托对象，而委托可以是一种类型
//3.C#自身提供了一种比较好的委托类型:EventHandler
//sender表示事件源，e表示事件相关的信息
public delegate void EventHandler(object sender, EventArgs e);
EventHandler CSharpDelegateHandler;
//4.另一种更好的委托方式是使用泛型参数的委托类型：EventHandler<TEventArgs>,其签名如下：
//如果产生额外参数，第二个参数是从 EventArgs 派生的类型并提供所有字段或属性需要保存事件数据。使用 EventHandler<TEventArgs> 的优点在于，如果事件生成事件数据，则无需编写自己的自定义委托代码。
public delegate void EventHandler<TEventArgs>(object sender, TEventArgs e);
//5.我们也可以为这些委托声明事件（EventHandler事件处理器就是事件）
public event EventHandler CSharpEventHandler;
//6.使用UnityEvent(可视) 和 UnityAction(不可视)
//使用类创建的话一条语句就等价于委托类的声明和委托对象的创建
public UnityAction unityAction;//本质是delegate
public UnityEvent unityEvent = new UnityEvent();//也可以在定义时new。本质上是继承自UnityEventBase的类

//7.Unity泛型委托
//因为UnityEvent<T0>是抽象类，所以需要声明一个类来继承它
public class UnityActionWithParameter: UnityEvent<int>{
//嵌套类
}
public UnityActionWithParameter unityActionWithParameter = new UnityActionWithParameter();
public UnityAction<int> unityIntAction;
public UnityEvent<int,int> unityIntEvent;
//8.泛型委托Action<T>和Func<T>
public Action<int, int> CSharpIntAction;//使用类创建的话一条语句就等价于委托类的声明和委托对象的创建
public Func<int, int, int> CSharpIntFunc;//最后一个int是函数返回类型
//注册的方法要求：返回类型+参数的类型+参数个数     参数名可以不同
int Add(int a, int b)
{
return a + b;
}
int Subtarct(int a,int b)
{
return a - b;
}
void NoParameter()
{
//无参方法
}
void OneIntParameter(int i)
{
//一个int参数,且返回void
}
void TwoIntParameter(int a,int b)
{
//2个int参数,且返回void
}
//针对EventHandler的注册方法
void OnGameStart(object sender, EventArgs e)
{
//你要执行的代码
}
//用法2：委托充当函数指针
static void functionPointer(MyDelegate function,int a,int b)
{
function(a, b);
}
void Start()
{
//委托对象的初始化和赋值 和普通类一致。注意由于声明的委托不包含0参构造函数，所以必须要注册参数
myDelegate =new MyDelegate(Add);
//C#事件添加方法
CSharpEvent += new MyDelegate(Add);
//其实这几个无论用=，+=都是可以的
CSharpDelegateHandler = new EventHandler(OnGameStart);
//另外还有其他的注册方式，这里就拿C#标准委托的事件为例
CSharpEventHandler += OnGameStart;
CSharpEventHandler -= OnGameStart;//当监听到后不需要执行这个方法时（取消监听）
CSharpEvent += Add;//同样可以
Dad dad = new Dad();
CSharpEvent += dad.Add;//如果我们想注册外部类的方法也是可以的（注意要public）
unityAction = new UnityAction(NoParameter);
unityAction += NoParameter;
//注意UnityEvent只能用AddListener临时注册方法
unityEvent.AddListener(NoParameter);
unityEvent.RemoveListener(NoParameter);
unityIntAction += OneIntParameter;//可以使用+=
unityIntAction = new UnityAction<int>(OneIntParameter);//注册要求一个int参数,且返回void
unityActionWithParameter.AddListener(OneIntParameter);//其实我不确定上面那个能不能用，实例中是只用了这行的事件的
unityIntEvent.AddListener(TwoIntParameter);//注册要求2个int参数,且返回void
CSharpIntAction += TwoIntParameter;//可以使用+=
CSharpIntAction = new Action<int, int>(TwoIntParameter);
CSharpIntFunc += Add;//要求返回int类型
CSharpIntFunc = new Func<int, int, int>(Add);
//9.lambda方式可以添加包含任意参数的函数，非常方便。以下是为onClick事件注册方法
GetComponent<Button>().onClick.AddListener(() =>
{//意思是用(参数列表)执行以下函数体的内容
//你要执行的代码，也可以执行方法，可以使用参数
});
//以下是调用。一般放在监听成功的位置
//C#委托的调用：委托对象及参数
myDelegate(1, 2);
myDelegate.Invoke(1,2);//调用与上面等价
//C#事件的调用，同委托完全一样
CSharpEvent(1, 2);
CSharpEvent.Invoke(2, 4);
//C#标准委托调用，注意不需任何参数时就这样
if(CSharpDelegateHandler!=null)//可以加个安全检查
CSharpDelegateHandler(this, EventArgs.Empty);
unityAction();//无参调用
unityAction.Invoke();
unityEvent.Invoke();//UnityEvent只能使用Invoke()调用
unityIntAction(1);//1个int参数
unityActionWithParameter.Invoke(1);//继承UnityAction<int>的事件
unityIntEvent.Invoke(1,2);//在Invoke中提供实参
CSharpIntAction(1, 2);//Invoke就省略不写了
CSharpIntFunc(1, 2);
//函数指针的使用
functionPointer(myDelegate, 2, 4);//可以用已有的委托对象做参数
functionPointer(new MyDelegate(Subtarct), 4, 2);//也可以new一个新对象
//另外如果对象是public的那么我们也可以在外部类执行以上代码
}
}

#include
<iostream.h>
#include
<list>
using namespace
std;

void max(int a,
int b)
{

    cout<<"now call max("<<a<<","<<b<<")..."<<endl;

    int t = a>b?a:b;

    cout<<t<<endl;
}
void min(int a,
int b)
{

    cout<<"now call min("<<a<<","<<b<<")..."<<endl;

    int t = a<b?a:b;

    cout<<t<<endl;
}
typedef
void (*myFun)(int a,
int b);
//定义一个函数指针用来引用max,min

//从这里开始看
//回调函数
void callback(myFun fun,
int a,
int b)
{也就是说，方法名成了一个参数fun,fun可以表示任何方法

    fun(a,b);
}
void main()
{

    int i = 10;

    int j = 55;

    callback(max,i,j);

    callback(min,i,j);
}