CS前置/后置事件框架

         把CommunityServer的事件框架应用到当前的项目中，可以在一个方法调用中设置其前置和后置事件，从而把一个额外的业务处理外置到别的模块中进行独立处理。
1、需要定义一系列的委托，如public delegate void PSPRoleEventHandler(PRole pRole, PSEventArgs e);委托参数的定义决定以后事件的参数，这里的PSEventArgs用于表示一些通用的参数传入，例如ObjectState针对对象操作的状态。

    public enum ObjectState
    {
        Create,
        Update,
        Delete,
        None,
        Runtime
    }

    public class PSEventArgs : EventArgs
    {
        private ObjectState _state;

        public ObjectState State
        {
            get { return _state; }
        }

        public PSEventArgs(ObjectState state)
        {
            _state = state;
        }

        public PSEventArgs() : this(ObjectState.None) { }
    }

2、创建PSApplication类，用于统一定义一些事件，并从配置文件的模块配置加载这些事件的真实调用，以下为一下例子：

    public class PSApplication
    {
        private members#region private members
        private EventHandlerList Events = new EventHandlerList();
        private static readonly object sync = new object();
        private Hashtable modules = new Hashtable();
        #endregion

        Event Keys (static)#region Event Keys (static)

        private static object EventPrePRoleUpdate = new object();
        private static object EventPRoleUpdate = new object();

        #endregion

        cnstr#region cnstr
        private PSApplication() { }
        internal static PSApplication Instance()
        {
            const string key = "PSApplication";
            HttpContext context = HttpContext.Current;

            PSApplication app = context.Cache[key] as PSApplication;
            if (app == null)
            {
                lock (sync)
                {
                    app = context.Cache[key] as PSApplication;
                    if (app == null)
                    {
                        PSConfiguration config = PSConfiguration.GetConfig();

                        XmlNode node = config.GetConfigSection("Configurations/PSModules");
                        app = new PSApplication();
                        if (node != null)
                        {
                            foreach (XmlNode n in node.ChildNodes)
                            {
                                if (n.NodeType != XmlNodeType.Comment)
                                {
                                    switch (n.Name)
                                    {
                                        case "clear":
                                            app.modules.Clear();
                                            break;
                                        case "remove":
                                            XmlAttribute removeNameAtt = n.Attributes["name"];
                                            string removeName = removeNameAtt == null ? null : removeNameAtt.Value;

                                            if (!String.IsNullOrEmpty(removeName) && app.modules.ContainsKey(removeName))
                                            {
                                                app.modules.Remove(removeName);
                                            }

                                            break;
                                        case "add":

                                            XmlAttribute en = n.Attributes["enabled"];
                                            if (en != null && en.Value == "false")
                                                continue;

                                            XmlAttribute nameAtt = n.Attributes["name"];
                                            XmlAttribute typeAtt = n.Attributes["type"];
                                            string name = nameAtt == null ? null : nameAtt.Value;
                                            string itype = typeAtt == null ? null : typeAtt.Value;

                                            if (String.IsNullOrEmpty(name))
                                            {
                                                //EventLogs.Warn("");
                                                continue;
                                            }

                                            if (String.IsNullOrEmpty(itype))
                                            {
                                                //EventLogs.Warn("");
                                                continue;
                                            }

                                            Type type = Type.GetType(itype);

                                            if (type == null)
                                            {
                                                //EventLogs.Warn("");
                                                continue;
                                            }

                                            IPSModule mod = Activator.CreateInstance(type) as IPSModule;

                                            if (mod == null)
                                            {
                                                //EventLogs.Warn("");
                                                continue;
                                            }

                                            mod.Init(app, n);//注意，通过Configurations/PSModules/[Model]/add节的配置可以传递一些扩展的配置
                                            app.modules.Add(name, mod);

                                            break;
                                    }
                                }
                            }
                        }

                        //以PSConfiguration的CacheKey为依赖项，即PSConfiguration的缓存过期，则本缓存也会过期
                        CacheDependency dep = new CacheDependency(null, new string[] { PSConfiguration.CacheKey });
                        context.Cache.Insert(key, app, dep);
                    }
                }
            }

            return app;
        }
        #endregion

        PRole Events#region PRole Events

        internal void ExecutePrePRoleUpdate(PRole pRole, ObjectState state)
        {
            PSPRoleEventHandler handler = Events[EventPrePRoleUpdate] as PSPRoleEventHandler;
            if (handler != null)
            {
                handler(pRole, new PSEventArgs(state));
            }
        }

        internal void ExecutePRoleUpdate(PRole pRole, ObjectState state)
        {
            PSPRoleEventHandler handler = Events[EventPRoleUpdate] as PSPRoleEventHandler;
            if (handler != null)
            {
                handler(pRole, new PSEventArgs(state));
            }
        }

        /**//// <summary>
        /// 触发事件，在PRole数据保存到数据库之前
        /// </summary>
        public event PSPRoleEventHandler PrePRoleUpdate
        {
            add { Events.AddHandler(EventPrePRoleUpdate, value); }
            remove { Events.RemoveHandler(EventPrePRoleUpdate, value); }
        }

        /**//// <summary>
        /// 触发事件，在PRole数据保存到数据库之后
        /// </summary>
        public event PSPRoleEventHandler PRoleUpdate
        {
            add { Events.AddHandler(EventPRoleUpdate, value); }
            remove { Events.RemoveHandler(EventPRoleUpdate, value); }
        }

        #endregion
    }

其中的internal static PSApplication Instance()方法用于实例化PSApplication对象并从配置文件中加载事件真实实现的模块信息，例如模块配置可以写成这样：

<Configurations>
    <PSModules>
        <add name="PRoleModule" type="CSDN.PermissionService.Components.PRoleModule, CSDN.PermissionService.Components" />    
    </PSModules>
</Configurations>

这样通过组件CSDN.PermissionService.Components中的CSDN.PermissionService.Components.PRoleModule模块就可以加载对角色操作的一些前后事件的功能
public event PSPRoleEventHandler PrePRoleUpdate 添加或移除在PRole数据保存到数据库之前的触发事件
public event PSPRoleEventHandler PRoleUpdate 添加或移除在PRole数据保存到数据库之后的触发事件
private EventHandlerList Events = new EventHandlerList(); 用于保存一下委托的事件列表

对于模块设计需要定实现一个IPSModule接口

    public interface IPSModule
    {
        void Init(PSApplication psa, XmlNode node);
    }

例如：PRoleModule

    public class PRoleModule : IPSModule
    {

        public void Init(PSApplication psa, System.Xml.XmlNode node)
        {
            psa.PrePRoleUpdate += new PSPRoleEventHandler(psa_PrePRoleUpdate);
            psa.PRoleUpdate += new PSPRoleEventHandler(psa_PRoleUpdate);
        }


        private void psa_PrePRoleUpdate(PRole pRole, PSEventArgs e)
        {
            //前置事件
        }

        private void psa_PRoleUpdate(PRole pRole, PSEventArgs e)
        {
            //后置事件
        }

    }

在模块里可以注册一些相关的事件，并且实现这些事件，以把一些前置或后置处理外置到主业务体外。
对于PSEvents是些方法调用的封装：

    public class PSEvents
    {
        PRoles#region PRoles

        public static void BeforePRole(PRole pRole, ObjectState state)
        {
            PSApplication.Instance().ExecutePrePRoleUpdate(pRole, state);
        }

        public static void AfterPRole(PRole pRole, ObjectState state)
        {
            PSApplication.Instance().ExecutePRoleUpdate(pRole, state);
        }

        #endregion
    }