DotNet(C#)实现事件远程注册和触发

背景:
以前做过一套分布式任务管理架构来为某网站提供数据计算服务，
该网站每次数据计算可以分解为几百个小任务进行，而每个任务可能需要访问的数据量很大，
所以系统有一个管理平台，用来显示系统的运行状态，或某类计算节点的运行压力，
用户也可以在平台上执行一些管理功能，为了应对平台上频繁的功能追加，在系统核心模块
添加了事件处理模块，每当用户需要在平台添加某个功能，只需要开发对应功能的一个功能模块，
该功能模块只需要在事件处理注册一个事件，即可执行执行来自平台的命令需求。该模块可发布在
局域网内的任何一台机器上。

下面看代码, 临时写的，简化或省略了其中的数据部分，省略了系统定义的事件树,没有注释-_-!!

多个模块可重复注册同一种事件，如模块自检

 

先定义一个事件容器:

 

[Serializable]
    public class EventHandlerSet : IDisposable
    {
        protected System.Collections.Hashtable events = new System.Collections.Hashtable();

        // indexer
        public virtual Delegate this[object eventKey]
        {
            get { return (Delegate)events[eventKey]; }
            set { events[eventKey] = value; }
        }

        public virtual void AddHandler(object eventKey, Delegate handler)
        {
            events[eventKey] = Delegate.Combine((Delegate)events[eventKey], handler);
        }

        public virtual void RemoveHandler(object eventKey)
        {
            events.Remove(eventKey);
        }

        public virtual void RemoveHandler(object eventKey, Delegate handler)
        {
            events[eventKey] = Delegate.Remove((Delegate)events[eventKey], handler);
        }

        // fire event
        public virtual void Fire(object eventKey, TaskEventArgs args)
        {
            if (!events.ContainsKey(eventKey))
            {
                return;
            }

            Delegate handler = (Delegate)events[eventKey];
            if (handler != null)
            {
                handler.DynamicInvoke(new object[] { eventKey, args });
            }
        }

        // Synchronized
        public static EventHandlerSet Synchronized(EventHandlerSet eventHandlerSet)
        {
            if (eventHandlerSet == null)
            {
                throw new Exception();
            }

            return new SynchronizedEventHandlerSet(eventHandlerSet);
        }

        public void Dispose()
        {
            events.Clear();
        }

    }

线程安全:

public delegate void TaskEventHandler(TaskEventArgs args);

[Serializable]
    public class SynchronizedEventHandlerSet : EventHandlerSet
    {
        private EventHandlerSet eventHandlerSet;

        public SynchronizedEventHandlerSet(EventHandlerSet eventHandlerSet)
        {
            this.eventHandlerSet = eventHandlerSet;

            Dispose();
        }

        // indexer
        public override Delegate this[object eventKey]
        {
            [MethodImpl(MethodImplOptions.Synchronized)]
            get { return eventHandlerSet[eventKey]; }

            [MethodImpl(MethodImplOptions.Synchronized)]
            set { eventHandlerSet[eventKey] = value; }
        }

        [MethodImpl(MethodImplOptions.Synchronized)]
        public override void AddHandler(object eventKey, Delegate handler)
        {
            eventHandlerSet.AddHandler(eventKey, handler);
        }

        [MethodImpl(MethodImplOptions.Synchronized)]
        public override void RemoveHandler(object eventKey)
        {
            eventHandlerSet.RemoveHandler(eventKey);
        }

        [MethodImpl(MethodImplOptions.Synchronized)]
        public override void RemoveHandler(object eventKey, Delegate handler)
        {
            eventHandlerSet.RemoveHandler(eventKey, handler);
        }