基本情况
事件系统里最基本的通知单元是一个容器，保存了一个事件的所有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就是一个回调容器，好激动啊，语言原生支持。
然而，它的实现选择是：
- Add一个handle两次，就调用两次。
- Remove不存在的handle，忽略之。
- 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表好像更好点。
个人想要的事件回调容器
情况处理的选择：
- 重复Add不生效
- Remove不存在的handle，忽略
- 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不会保存野指针。
