分析分发器的基础结构（C#）

一、什么是分发器（Dispatcher）

分发器：对数据进行处理后，进行数据分发的中介。主要手段是通过事件的提前注册在分发器内，当被触发时，处理触发者传入的数据，然后传入数据给提前注册好在分发器内的事件，并且回调这些事件。

二、分发器的类结构

1、注册的回调函数定义

	public delegate void NetCallBack0();
    public delegate void NetCallBack1(Object objcet);

注册的函数类型根据应用的场景不一样，需要设计不一样的函数参数和返回类型。
函数参数可设计为泛型类，该类继承于一个信息基础父类或者接口。以传递数据。

比如：
（1）在网络分发器中，如果使用的是Protobuf协议，参数可以传入，其数据基类。
（2）在UI中的事件分发器中，可以使用组件的基类作为参数，如FairyGui的GObject类。

2、事件类(Bridge)

使用上面定义的委托类型创建一个事件，在事件类中实现添加、删除、调用等功能。

public class Bridge {
		//Dispatcher owner;
        private event NetCallBack0 _callBack0;
        private event NetCallBack1 _callBack1;
        //需要多个分发器时可记录归属者
		//public Bridge(Dispatcher owner)
        //{
            //this.owner = owner;
        //}
        public void Add(NetCallBack0 _callBack) {
            this._callBack0 += _callBack;
        }

        public void Add(NetCallBack1 _callBack)
        {
            this._callBack1 += _callBack;
        }

        public void Remove(NetCallBack0 cb) {
            this._callBack0 -= cb;
        }

        public void Call() {
            this._callBack0?.Invoke();
        }

        public void Call(Object obj) {
            this._callBack1?.Invoke(obj);
        }

        public void Remove(NetCallBack1 cb)
        {
            this._callBack1 -= cb;
        }
    }

3、监听者(Listener)

监听者自身拥有一个事件类（Bridge），以及一个类型（type）。这个类型与事件类绑定，这样就可通过注册时申请的类型做绑定。

 class Listener
    {
        Bridge _bridge;
        string _type;
        public Listener(Dispatcher own, string type) {
            this._bridge = own.GetBridge(type);
            this._type = type;
        }
    }

4、分发器（Dispatch）

分发器内通过一个字典管理监听者（Listener），在分发器内注册监听者，通过一个类型添加到字典，并且（创建监听者）添加事件。

 public interface IDispatcher
    {
        public void AddListener(string type, NetCallBack0 callBack);
        public void AddListener(string type, NetCallBack1 callBack);
        public void RemoveListener(string type, NetCallBack0 callBack);
        public void RemoveListener(string type, NetCallBack1 callBack);

    }

    public class Dispatcher : IDispatcher
    {
        Dictionary<string, Bridge> dic;

        public Bridge GetBridge(string type) {
            Bridge bridge = null;
            if (dic == null) { 
                dic = new Dictionary<string, Bridge>();
            }
            if (!dic.TryGetValue(type, out bridge)) {
                bridge = new Bridge();
                dic.Add(type, bridge);
            }
            return bridge;
            
        }

        public void AddListener(string type, NetCallBack0 callback)
        {
            GetBridge(type).Add(callback);
        }

        public void AddListener(string type, NetCallBack1 callback)
        {
            GetBridge(type).Add(callback);
        }

        public void DispatchEvent(string type) {
            GetBridge(type).Call();
        }

        public void DispatchEvent(string type, Object obj)
        {
            GetBridge(type).Call(obj);
        }

        public void RemoveListener(string type, NetCallBack0 callBack0)
        {
            Bridge bridge = null;
            if (dic.TryGetValue(type, out bridge)) {
                bridge.Remove(callBack0);
            }
        }

        public void RemoveListener(string type, NetCallBack1 callBack0)
        {
            Bridge bridge = null;
            if (dic.TryGetValue(type, out bridge))
            {
                bridge.Remove(callBack0);
            }
        }

    }

上面只一个简单的框架，根据不同的需求需要更多的类和更复杂的结构。
比如在网络的分发器中，还需要添加对数据的反序列化和序列化功能的类。

以上是个人的总结，如果有其他想法，欢迎多沟通多交流，提前感谢大哥能给在下一个交流的机会。