基本情况

事件系统里最基本的通知单元是一个容器，保存了一个事件的所有handle。

interface Contain{
    function Add(handle);
    function Remove(handle);
    function Notify(event, params);
}

有几个情况要处理：

• Add两次同一个handle怎么处理？1. Add两次,2. 忽略,3. 还是异常。
• Remove时，如果handle不存在怎么处理？1. 忽略，2. 还是异常。
• Prcocess遍历执行handle过程中，又来了Add或者Remove请求怎么办？1. 延后生效，2. 立即生效。

C#的选择

C#的delegate和event就是一个回调容器，好激动啊，语言原生支持。
然而，它的实现选择是：

1. Add一个handle两次，就调用两次。
2. Remove不存在的handle，忽略之。
3. Add和Remove都延后生效。这意味着一个在Process执行过程中remove的handle还是会被调用。

有些不理解，为啥这样。Add两次还好说，Remove延后可能出锅啊！
一个测试代码

    public delegate void EventHandle(params object[] objs);
    public event EventHandle _event;

    void Awake()
    {
        _event += this.a;
        _event += this.b;

        Debug.Log("notify 1");
        _event(); // a b
        Debug.Log("notify 2");
        _event(); // a c c

    }

    void a(params object[] objs)
    {
        Debug.Log("a");
        _event += this.c;// 延后生效，c下次执行
        _event += this.c;// c加了两次，最后会执行两次
        _event -= this.b;// 延后生效 ,b还是会执行
    }

    void b(params object[] objs)
    {
        Debug.Log("b");
    }

    void c(params object[] objs)
    {
        Debug.Log("c");
    }

猜测实现类似这样，因为delegate的结构基础是个链表。

class event{
    _list;
    _delay_remove_or_add_list;
    function Add(handle)
        // O(1) add to tail
        _delay_remove_or_add_list += [add,handle]
    end
    function Remove(handle)
        _delay_remove_or_add_list += [remove,handle]
    end
    fucntion _DelayOperate()
        for type,handle in _delay_remove_or_add_list do
            if type is add then
                _list += handle
            else
                // O(1)~O(m)
                // travel _list from tail to head look for handle, then remove it
                // if handle is not in _list，then will travel all then _list

            end
        end
        _delay_remove_or_add_list.Clear()
    end
    function Notify(params)
        _DelayOperate()
        // run all handle in _list
    end
}

上面的实现里_DelayOperate()可能退出成O(n*m)，可以做个hash优化啥的达到O(n+m)。

C#用链表做容器，应该是处于保证执行顺序的目的吧，不然用Hash表好像更好点。

个人想要的事件回调容器

情况处理的选择：

1. 重复Add不生效
2. Remove不存在的handle，忽略
3. Add延时生效，Remove立即生效。

一种通用实现思路，用hash做容器，伪代码

class EventHandleContain{
    Hash<Handle> _contain;
    bool _is_runing = false; 
    Hash<Handle,bool> _delay_ops;
    function Add(handle)
        if _is_runing then
           _delay_ops[handle] = false 
        else
           _contain.Add(handle)   
        end
    end
    function Remove(handle)

        if _is_runing then
           _delay_ops[handle] = true
        else
           _contain.Remove(handle)
        end
    end
    fucntion _DelayOperate()
        for handle,is_remove in _delay_ops do
            if is_remove then
                _hash.Remove(handle)
            else
                _hash.Add(handle)
            end
        end
        _delay_ops.Clear()
    end
    function Notify(params)
        _is_runing = true;
        for handle in _hash do
            if _delay_ops[handle] then
                contine;
            end
            handle(params)
        end
        _is_runing = false;
        _DelayOperate()
    end
}

PS:
可以通过在每个通知对象上加四个状态（初始化、待添加、已加入、待删除）。
用O(1)链表的方式实现事件系统，具备同样的效果

游戏里的tick系统

游戏里一帧会有很多物体更新，可以理解成他们都监听或订阅了tick事件。
但是用上面的事件系统来实现有个问题，添加顺序和执行顺序可能不一致。
对于要同步或者回放的游戏来说是不可接受的。

这个有一个简单的实现方案。
几个情况的处理：物体只能添加一次，Add立即生效，Remove和延时销毁有关，可以认为死亡立即生效,
用链表做容器，物体继承ObjectBase，有个存活标识。
物体的生命周期:出生->添加到各个管理器->update->死亡待删除->各个管理器删除->死亡->下一轮回。

伪代码

interface ITick{
    void IsReadyToDestroy();// 销毁是延时的，有一次机会删掉
    void OnTick();
}

class TickContain{
    List<ITick> _list;
    function Add(ticker)
        _list += ticker;// 可以添加多次的
    end
    function Tick()
        iterator = _list.Begin()
        while iterator != _list.End() do
            if iterator->IsReadyToDestroy() then
                iterator = _list.Remove(iterator)
            else
                iterator->OnTick()
                iterator = iterator.next

            end

        end
    end
}

核心点是延时销毁，保证任何时候TickContain不会保存野指针。