UNITY_委托和事件

UNITY_委托和事件

参考资料: Unity3D脚本编程-使用C#语言开发跨平台游戏-陈嘉栋

观察者模式

主题(Subject)管理某些数据，当主题的数据发生改变时，会通知已经注册(Register)的观察者(Observer)，而这些已经注册的观察者会受到数据改变的通知并做出相应反应。

观察者模式定义了对象之间的一对多依赖，当一个对象改变状态时，它的全部依赖者都会受到通知并自动更新。

Unity提供的机制：SendMessage()和BroadcastMessage()

缺点:
　　过于依赖反射机制(reflection)来查找消息对应的被调用函数
　　1. 频繁使用反射会影响性能
　　2. 更会大大增长代码的维护成本 -- 字符串标识对应方法
　　3. 可以调用private的方法 -- 如有一个是有方法在声明的类中没有被使用，那正常状况下都会把它认为是废代码从而删除，这时隐患就出现了

C#的委托机制

c#中提供的回调函数的机制即是委托(类型安全)

委托的使用

public class DelegateScript: MonoBehaviour{
    internal delegate void MyDelegate(int num); // 声明委托类型(参数列表+返回类型)\
    MyDelegate myDelegate; // 声明变量

    void Start(){
        myDelegate = PrintNum; // 给委托类型MyDelegate的实例赋值引用的方法
        myDelegate(50);

        myDelegate = DoubleNum;
        myDelegate(50);
    }
    
    void PrintNum(int num){
        ...
    }
    void DoubleNum(int num){
        ...
    }
}

这里myDelegate = PrintNum; 将一个方法"赋值"给了一个委托
　　在c#2中为委托引入了方法组转换机制，支持从方法到兼容的委托类型的隐式转换
　　之因此成为方法"组"转换，则是由于方法的重载

如有delegate void Delegate1(int num)
　和delegate void Delegate2(int num, int num2)
且有方法 void PrintNum(int num)
　　和  void PrintNum(int num, int num2)
　　则  myDelegate1 = PrintNum;
　　　  myDelegate2 = PrintNum;
　　向  myDelegate1或myDelegate2赋值时，均可以使用PrintNum做为方法组（由于重载了多个方法）
　　而编译器会自动选择合适的重载

委托参数的逆变性
　　逆变性: 能够是类型的基类
　　即委托对应方法的参数能够是委托的参数类型的基类

委托返回类型的协变性
　　协变性: 能够是类型派生出来的一个派生类
　　即委托对应方法的返回类型能够是委托的返回类型的一个派生类

逆变性和协变性仅针对引用类型，如果值类型或void则不支持

委托的编译器内部实现机理

（略） -- p154~164

委托链

委托调用多个方法 -- 委托链
委托链是委托对象的集合 -- 能够利用委托链来调用集合中的委托所表明的所有方法

public class DelegateScript : MonoBehaviour {
    delegate void MyDelegate(int num);
    
    void Start(){
        MyDelegate myDelegate1 = new MyDelegate(PrintNum1);
        MyDelegate myDelegate2 = new MyDelegate(PrintNum2);
        MyDelegate myDelegate3 = new MyDelegate(PrintNum3);

        MyDelegate myDelegates = null;
        myDelegates = (MyDelegate)Delegate.Combine(myDelegates, myDelegate1);
        myDelegates = (MyDelegate)Delegate.Combine(myDelegates, myDelegate2);
        myDelegates = (MyDelegate)Delegate.Combine(myDelegates, myDelegate3);

        Print(10, myDelegates);
    }

    void Print(int num, MyDelegate md){
        if(md != null){
            md(value);
        }
    }

    void PrintNum1(int num) { Debug.Log("1 result Num: " + num); }
    void PrintNum2(int num) { Debug.Log("2 result Num: " + num); }
    void PrintNum3(int num) { Debug.Log("3 result Num: " + num); }
｝

刚开始时myDelegates = null; 表示没有对应要回调的方法
第一次myDelegates = (MyDelegate)Delegate.Combine(myDelegates, myDelegate1);时myDelegates引用了myDelegate1所引用的委托实例
第二次时，myDelegates内部实现的_invocationList字段被初始化，而且_invocationList[0]指向和_invocationList[1]分别指向两个委托实例myDelegate1和myDelegate2
第三次是将一个委托实例myDelegate3合并到一个委托链中。编译器内部发生的与第二次的大同小异。须要注意的是，第二次获得的委托链中的_invocationList所引用的委托实例数组再也不须要，被垃圾回收
将myDelegates变量(委托链)做为参数传入Print()，Print方法中的代码会隐式调用myDelegates所引用的委托实例的Invoke()方法，
　　此时会执行一个循环来遍历_invocationList中的全部委托实例并按顺序调用每一个委托实例中包装的回调方法，即PrintNum1(), PrintNum2()和PrintNum3()

对应Delegate.Combine(), 也提供了Remove()方法用于移除委托实例
　　Remove()每次仅仅移除一个匹配的委托实例，而不是全部和目标委托实例匹配的委托实例
　　myDelegates = (MyDelegate)Delegate.Remove(myDelegates, new MyDelegate(PrintNum2));

当Remove方法被调用时，会从后向前扫描myDelegates中的委托实例数组，并对比委托实例的_target和_methodPtr的值是否与须要Remove的对应字段值相同。
若匹配，则删除。若是委托实例数组为空，则返回null；若是委托实例数组长度为1，则直接返回那个委托实例；
不然，会建立一个新的委托实例(与Combine出委托链相似)，对应的_invocationList会引用由删除了目标委托实例后剩余委托实例组成的委托实例数组。

C#编译器为委托类型的实例重载了 += 和 -= 操做符，对应Delegate.Combine()和Delegate.Remove()

事件

观察者模式能够经过事件机制来实现

C#中的事件机制是以委托做为基础的

一个定义了事件成员的类型须要提供这些功能来实现交互机制
　　1. 方法可以订阅对某事件的关注
　　2. 方法可以取消订阅对该事件的关注
　　3. 事件发生时，订阅了该事件的方法会收到通知

实例：

一个游戏单位(BaseUnit类)被攻击而掉血，那么掉血(OnSubHp事件)就能够被做为一个事件。
订阅了该事件的对象在游戏单位掉血时，会收到游戏单位掉血的通知。

具体需求：掉血时，须要显示掉血信息，掉血信息中有多个值。

思路：为了区分开游戏单位和显示信息的逻辑（下降逻辑的耦合性），将掉血信息的显示逻辑交给模块BattleInfoComponent
--> 即游戏单位的掉血事件OnSubHp发生时，通知BattleInfoComponent模块来处理显示功能。

实现：

1. 定义委托类型(回调方法原型) -- 事件是以委托为基础的

public delegate void SubHpHandler(BaseUnit source, float subHp, DamageType damageType, HpShowType showType);
-- source: 受伤害的单位；subHp: 伤害；damageType: 伤害方式；showType: 显示方式

2. 定义事件成员

使用关键字event定义事件成员
public event SubHpHandler OnSubHp;

表示事件OnSubHp的类型为SubHpHandler，意味着事件OnSubHp的全部订阅者都必须提供和SubHpHandler委托类型所肯定的方法原型相匹配的回调方法，即void Method(BaseUnit .., float .., DamageType .., HpShowType ..);

3. 事件的触发

这里的BaseUnit能够视为一个基类，派生出好比英雄类、士兵类等。
所以，触发事件的方法能够定义为一个虚方法
本例中，OnSubHp事件是受到攻击而致使的，所以

protected virtual void OnBeAttacked(float damage, bool isCritical, bool isMissed){
    DamageType damageType = DamageType.Normal;
    HpShowType showType = HpShowType.Damege;
    if(isCritical) damageType = DamageType.Critical;
    if(isMissed) showType = HpShowType.Miss;
    // 若是有方法订阅了OnSubHp事件，则调用(通知)
    if(OnSubHp != null) {
        OnSubHp(this, damage, damageType, showType);
    }
}

而BaseUnit的派生类能够经过重写OnBeAttack()来控制事件的触发

优化：业务单一原则

OnBeAttack()方法应该仅仅用来触发事件
所以
BeAttack()方法用来将敌人的攻击伤害转化为掉血事件的触发

public void BeAttack() {
    bool isCritical = Random.value > 0.5f;
    bool isMissed = Random.value > 0.5f;
    float damage = 10000f;
    
    OnBeAttacked(damage, isCritical, isMissed);
} 

4. 事件的订阅和观察者的回调方法

以前提到的BattleInfoComponent类是用来进行伤害信息显示的
而伤害信息显示的时机是在BaseUnit受到伤害的时候
所以BattleInfoComponent须要订阅BaseUnit.OnSubHp事件。

public class BattleInfoComponent: MonoBehaviour {
    public BaseUnit baseUnit;
    ...
    
    private void AddListener () {
        // 订阅事件this.unit.OnSubHp
        this.unit.OnSubHp += new BaseUnit.SubHpHandler(this.OnSubHp);
        // 可简写为
        unit.OnSubHp += OnSubHp;
    }

    private void RemoveListener () {
        // 不要忘记取消事件的订阅
        this.unit.OnSubHp -= new BaseUnit.SubHpHandler(this.OnSubHp);
    }

    private void OnSubHp(BaseUnit source, float damage, DamageType dmgType, HpShowType showType) {
        // 实现伤害信息的显示功能
        Debug.Log(source.name + ....);
    }
}

c#的+=操做符可用于注册事件
　　this.unit.OnSubHp += new BaseUnit.SubHpHandler(Method);
　　可简写为
　　this.unit.OnSubHp += Method;
　　上述两行代码的内部在编译器内部其实都等效于
　　this.unit.add_OnSubHp(new BaseUnit.SubHpHandler(this.OnSubHp));

　　在订阅事件时，编译器内部须要调用事件的add_OnSubHp方法来向事件内部添加新的委托对象

取消回调事件的订阅也类似，使用-=操做符
　　在编译器内部等效于
　　this.unit.remove_OnSubHp(new BaseUnit.SubHpHandler(this.OnSubHp));

总结：

当UnitBase受到攻击时，执行UnitBase.BeAttack()
　　--> UnitBase.OnBeAttacked()被调用
　　--> 触发UnitBase.OnSubHp事件
　　因为BattleInfoComponent.OnSubHp()方法订阅了UnitBase.OnSubHp事件
　　--> 所以在UnitBase.OnSubHp事件触发时，BattleInfoComponent.OnSubHp()方法被调用
　　　　而OnSubHp()方法会受到来自UnitBase.OnSubHp事件传来的参数source等
　　　　基于这些参数，OnSubHp()方法得以将伤害信息显示出来

事件的编译器内部实现机理

（略） -- p169~17二、175

优势：

在事件机制中，事件成员(OnSubHp)才拥有数据，
　　这些数据不属于观察者，可是观察者须要依赖Subject的这些数据作出响应
　　若是有不少不一样的观察者经过订阅同一个Subject，Subject的数据变化而触发了事件时，全部观察者会受到相应通知

经过事件机制能够将对象之间的相互依赖降到最低 -- 松耦合
　　观察者模式的意义也在于此，让主题和观察者之间实现松耦合的设计模式
　　当两个对象之间松耦合，即便不清楚彼此的细节，也能够进行交互

在有新类型的观察者出现时，主题(Subject)的代码无需修改，而新类型只须要实现匹配的回调方法便可注册成观察者