服务层的设计

服务层代码

首先我先放出2个主要类的代码再分别讲解

接口

实现

查询实体

上一节提到Specification实现查询功能，主要实现Where功能，但是查询还需要数据承载，查询实体就是数据的承载，其中数据到表达式或者sql的拼接就是在GetFilter中实现的，这里要注意写法特别是 expression=expression.And(xxx).一定要赋值给自己。SearchBase只是一个泛型限制里面暂时没有任何实现

以下是一个GetFilter实现

protected override ISpecification<PrivateLesson> GetFilter(LessonSearch search)
{
    var expression = (Expression<Func<PrivateLesson, bool>>)(item => true);
    if (search == null)
        return base.GetFilter(null);
    if (search.StartTime != default(DateTime))
        expression = expression.And(item => item.StartTime > search.StartTime);
 
    if (search.EndTime != default(DateTime))
        expression = expression.And(item => item.StartTime < search.EndTime);
 
    if (!string.IsNullOrWhiteSpace(search.Text))
        expression =
            expression.And(item => item.Name.Contains(search.Text) || item.Coach.Name.Contains(search.Text));
 
    return new DirectSpecification<PrivateLesson>(expression);
}

排序实体

等同于查询实体，排序实体也是排序功能的数据承载，OrderBase只是一个泛型限制，里面暂时没有任何实现

泛型维度的缩放

对于上面排序和查询的功能并不是一定都需要，所以做了维度缩放，可以从三种
维度去使用Crud的服务.
对于服务的实现上加入了模型实体(也就是和数据库映射的模型)，这么做的好处是
使用接口的人无需知道数据库怎么存放表怎么映射，接口和实现分离。

Mapper

我们选用EmitMapper作为Entity和DTO的映射，目前来看这个性能是除了直接赋值
之外性能最好的了，网上有很多对比文章请自行参考。当然如果你不习惯也可以
换一种实现

这里代码参考NLayerApp中Mapper的设计，略作修改

注意这里配置文件采用Dynamic的方式可以让简单使用的地方不需要引用EmitMapper，

除非是要做一些扩展

namespace Coralcode.Framework.Mapper
{
    public class DataMapperProvider
    {
        public static IDataMapper  Mapper
        {
            get { return new EmitmapperDataMapper(); }
        }
    }
}
 
 
 
namespace Coralcode.Framework.Mapper
{
    public interface IDataMapper
    {
        TTarget Convert<TSource, TTarget>(TSource source)
            where TTarget : class, new()
            where TSource : class;
 
        TTarget Convert<TSource, TTarget>(TSource source, TTarget target)
            where TTarget : class
            where TSource : class;
 
        /// <summary>
        /// 带配置文件的转换
        /// </summary>
        /// <typeparam name="TSource"></typeparam>
        /// <typeparam name="TTarget"></typeparam>
        /// <param name="source"></param>
        /// <param name="target"></param>
        /// <param name="config">配置文件</param>
        /// <returns></returns>
        TTarget Convert<TSource, TTarget>(TSource source, TTarget target, dynamic config)
            where TTarget : class
            where TSource : class;
 
        /// <summary>
        /// 带配置文件的转换
        /// </summary>
        /// <typeparam name="TSource"></typeparam>
        /// <typeparam name="TTarget"></typeparam>
        /// <param name="source"></param>
        /// <param name="config">配置文件</param>
        /// <returns></returns>
        TTarget Convert<TSource, TTarget>(TSource source, dynamic config)
            where TTarget : class, new()
            where TSource : class;
    }
}
 
using EmitMapper;
using EmitMapper.MappingConfiguration;
 
namespace Coralcode.Framework.Mapper
{
    public class EmitmapperDataMapper
        : IDataMapper
    {
        #region ITypeAdapter Members
 
        public TTarget Convert<TSource, TTarget>(TSource source)
            where TSource : class
            where TTarget : class, new()
        {
            ObjectsMapper<TSource, TTarget> mapper =
                ObjectMapperManager.DefaultInstance.GetMapper<TSource, TTarget>(new DefaultMapConfig());
            return mapper.Map(source);
        }
 
        public TTarget Convert<TSource, TTarget>(TSource source, TTarget target)
            where TTarget : class
            where TSource : class
        {
            ObjectsMapper<TSource, TTarget> mapper =
                ObjectMapperManager.DefaultInstance.GetMapper<TSource, TTarget>(new DefaultMapConfig());
            return mapper.Map(source, target);
        }
 
 
        public TTarget Convert<TSource, TTarget>(TSource source, TTarget target, dynamic config)
            where TTarget : class
            where TSource : class
        {
            ObjectsMapper<TSource, TTarget> mapper =
                ObjectMapperManager.DefaultInstance.GetMapper<TSource, TTarget>((DefaultMapConfig)config);
            return mapper.Map(source, target);
        }
 
 
        public TTarget Convert<TSource, TTarget>(TSource source, dynamic config)
            where TTarget : class, new()
            where TSource : class
        {
            ObjectsMapper<TSource, TTarget> mapper =
                ObjectMapperManager.DefaultInstance.GetMapper<TSource, TTarget>(config);
            return mapper.Map(source);
        }
 
        #endregion
    }
}

EF更新机制

EF更新这也是我经常使用的一个面试题，很多人会回答直接由Update方法可以调用
实际上ef是通过代理对象并且实现INotifyChange接口来监听属性的改变。
EF更新的时候不能修改主键的值，所以我这里做了忽略。其他属性全部更新，
当然如果涉及到具体业务比如修改账号或者金额之类的修改，最好是扩展服务实现
不要用这个服务中自带的更新方法，直接使用Repository去更新

Attribute注入配置化

这里我使用Attribute做Ioc配置，其中生命周期的枚举参考unity框架的设计，
具体怎么使用可以参考网上的文章。
实现机制是在一个用启动的时候扫描程序集有这个标记的类型，然后读出
RegisterType做注册，并且支持多注册

UnityService的代码

注意这里Register方法最后一个参数用dynamic，这样使用的地方就可以不依赖于Unity,

其中包含了Aop和几个设计技巧，有问题的可以留言我再做解答

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using Coralcode.Framework.Extensions;
using Coralcode.Framework.Reflection;
using Microsoft.Practices.Unity;
using Microsoft.Practices.Unity.InterceptionExtension;
 
namespace Coralcode.Framework.Aspect.Unity
{
    /// <summary>
    /// IOC容器
    /// </summary>
    public class UnityService
    {
 
        static UnityService()
        {
            //注册标记
            Current = new UnityContainer();
            Current.AddNewExtension<Interception>();
 
            var currentType = typeof(UnityService);
            var containers = new List<dynamic>();
 
 
            //模块初始化
            containers.ForEach(item => item.Regist());
            //模块启动
            containers.ForEach(item => item.RegistComplete());
            MetaDataManager.Type.GetAllTypes().ForEach(item =>
            {
                if (item == null)
                    return;
 
                var registers = item.GetCustomAttributes<InjectAttribute>().ToList();
                if (registers.Count == 0)
                    return;
                registers.ForEach(register =>
                {
                    if (register.RegisterType != null)
                        RegisterType(register.Name, register.RegisterType, item, GetLifetimeManager(register.LifetimeManagerType), GetInjectionMembers(register.AopType, item));
                    else
                        RegisterType(register.Name, item, GetLifetimeManager(register.LifetimeManagerType), GetInjectionMembers(register.AopType, item));
                });
            });
        }
 
        #region 属性
 
        /// <summary>
        ///     Get the current configured container
        /// </summary>
        /// <returns>Configured container</returns>
        private static IUnityContainer Current { get; set; }
 
 
        #endregion
 
 
        /// <summary>
        /// 在当前模块中注册接口的实现
        /// </summary>
        protected virtual void Regist()
        {
        }
        /// <summary>
        /// 在当前模块中注册应用程序启动事件
        /// </summary>
        protected virtual void RegistComplete()
        {
        }
 
        #region 注册相关的方法
        /// <summary>
        /// 获取生命周期
        /// </summary>
        /// <param name="lifetimeManagerType"></param>
        /// <returns></returns>
        public static LifetimeManager GetLifetimeManager(LifetimeManagerType lifetimeManagerType)
        {
            switch (lifetimeManagerType)
            {
                case LifetimeManagerType.Transient:
                    return new TransientLifetimeManager();
                case LifetimeManagerType.ContainerControlled:
                    return new ContainerControlledLifetimeManager();
                case LifetimeManagerType.Hierarchica:
                    return new HierarchicalLifetimeManager();
                case LifetimeManagerType.Externally:
                    return new ExternallyControlledLifetimeManager();
                case LifetimeManagerType.PerThread:
                    return new PerThreadLifetimeManager();
                case LifetimeManagerType.PerResolve:
                    return new PerResolveLifetimeManager();
                default:
                    return new TransientLifetimeManager();
            }
        }
 
        /// <summary>
        /// 注入aop方法
        /// </summary>
        /// <param name="aopType"></param>
        /// <param name="type"></param>
        /// <returns></returns>
        public static InjectionMember[] GetInjectionMembers(AopType aopType, Type type)
        {
            var members = new List<InjectionMember>();
            switch (aopType)
            {
                case AopType.VirtualMethodInterceptor:
                    members.Add(new Interceptor<VirtualMethodInterceptor>());
                    break;
                case AopType.InterfaceInterceptor:
                    members.Add(new Interceptor<InterfaceInterceptor>());
                    break;
                case AopType.TransparentProxyInterceptor:
                    members.Add(new Interceptor<TransparentProxyInterceptor>());
                    break;
            }
            members.AddRange(type.GetCustomAttributes()
                   .Where(item => item.GetType().IsSubclassOf(typeof(UnityAopAttribute)))
                   .Cast<UnityAopAttribute>()
                   .Select(item => new InterceptionBehavior(item)));
            return members.ToArray();
 
        }
        #endregion
 
        /// <summary>
        ///     注册泛型类型
        /// </summary>
        /// <param name="injectionMembers">构造函数参数</param>
        public static void Register<TTarget, TSource>(params dynamic[] injectionMembers) where TSource : TTarget
        {
            RegisterType<TTarget, TSource>("",injectionMembers);
        }
 
 
 
        /// <summary>
        ///     注册泛型类型
        /// </summary>
        /// <param name="name"></param>
        /// <param name="injectionMembers">构造函数参数</param>
        public static void RegisterType<TTarget, TSource>(string name, params dynamic[] injectionMembers) where TSource : TTarget
        {
            var members = new List<InjectionMember>();
            LinqExtensions.ForEach(injectionMembers, item =>
            {
                if (item is InjectionMember)
                    members.Add(item);
                if (item is InjectionMember[])
                    members.AddRange(item);
                else if (item is ConstructorParameter)
                    members.Add(new InjectionConstructor(item.Value));
                else if (item is ConstructorParameter[])
                    members.AddRange((item as ConstructorParameter[]).Select(data => new InjectionConstructor(data.Value)));
            });
 
            var lifetimeManager = injectionMembers.OfType<LifetimeManager>().FirstOrDefault();
            if (string.IsNullOrEmpty(name))
            {
                if (lifetimeManager == null && injectionMembers == null)
                    Current.RegisterType<TTarget, TSource>();
 
                else if (lifetimeManager == null)
                    Current.RegisterType<TTarget, TSource>(members.ToArray());
                else if (injectionMembers == null)
                    Current.RegisterType<TTarget, TSource>(lifetimeManager);
                else
                    Current.RegisterType<TTarget, TSource>(lifetimeManager, members.ToArray());
 
            }
            else
            {
                if (lifetimeManager == null && injectionMembers == null)
                    Current.RegisterType<TTarget, TSource>(name);
 
                else if (lifetimeManager == null)
                    Current.RegisterType<TTarget, TSource>(name, members.ToArray());
                else if (injectionMembers == null)
                    Current.RegisterType<TTarget, TSource>(name, lifetimeManager);
                else
                    Current.RegisterType<TTarget, TSource>(name, lifetimeManager, members.ToArray());
 
            }
        }
 
 
        /// <summary>
        /// 注册类型
        /// </summary>
        /// <param name="source"></param>
        /// <param name="target"></param>
        /// <param name="lifetimeManager"></param>
        /// <param name="injectionMembers"></param>
        public static void RegisterType(string name, Type target, Type source, params dynamic[] injectionMembers)
        {
            var members = new List<InjectionMember>();
            LinqExtensions.ForEach(injectionMembers, item =>
            {
                if (item is InjectionMember)
                    members.Add(item);
                if (item is InjectionMember[])
                    members.AddRange(item);
                else if (item is ConstructorParameter)
                    members.Add(new InjectionConstructor(item.Value));
                else if (item is ConstructorParameter[])
                    members.AddRange((item as ConstructorParameter[]).Select(data => new InjectionConstructor(data.Value)));
            });
            var lifetimeManager = injectionMembers.OfType<LifetimeManager>().FirstOrDefault();
 
 
            if (string.IsNullOrEmpty(name))
            {
 
                if (lifetimeManager == null && injectionMembers == null)
                    Current.RegisterType(target, source);
                else if (lifetimeManager == null)
                    Current.RegisterType(target, source, members.ToArray());
                else if (injectionMembers == null)
                    Current.RegisterType(target, source, lifetimeManager);
                else
                    Current.RegisterType(target, source, lifetimeManager, members.ToArray());
 
            }
            else
            {
                if (lifetimeManager == null && injectionMembers == null)
                    Current.RegisterType(target, source, name);
                else if (lifetimeManager == null)
                    Current.RegisterType(target, source, name, members.ToArray());
                else if (injectionMembers == null)
                    Current.RegisterType(target, source, name, lifetimeManager);
                else
                    Current.RegisterType(target, source, name, lifetimeManager, members.ToArray());
            }
        }
 
        /// <summary>
        /// 注册类型
        /// </summary>
        /// <param name="source"></param>
        /// <param name="target"></param>
        /// <param name="lifetimeManager"></param>
        /// <param name="injectionMembers"></param>
        public static void RegisterType(Type target, Type source, params dynamic[] injectionMembers)
        {
            var members = new List<InjectionMember>();
            LinqExtensions.ForEach(injectionMembers, item =>
            {
                if (item is InjectionMember)
                    members.Add(item);
                if (item is InjectionMember[])
                    members.AddRange(item);
                else if (item is ConstructorParameter)
                    members.Add(new InjectionConstructor(item.Value));
                else if (item is ConstructorParameter[])
                    members.AddRange((item as ConstructorParameter[]).Select(data => new InjectionConstructor(data.Value)));
            });
            var lifetimeManager = injectionMembers.OfType<LifetimeManager>().FirstOrDefault();
 
 
 
 
            if (lifetimeManager == null && injectionMembers == null)
                Current.RegisterType(target, source);
            else if (lifetimeManager == null)
                Current.RegisterType(target, source, members.ToArray());
            else if (injectionMembers == null)
                Current.RegisterType(target, source, lifetimeManager);
            else
                Current.RegisterType(target, source, lifetimeManager, members.ToArray());
        }
 
        /// <summary>
        /// 注册类型
        /// </summary>
        /// <param name="injectionMembers"></param>
        public static void RegisterType(Type type, params dynamic[] injectionMembers)
        {
            var members = new List<InjectionMember>();
            LinqExtensions.ForEach(injectionMembers, item =>
            {
                if (item is InjectionMember)
                    members.Add(item);
                if (item is InjectionMember[])
                    members.AddRange(item);
                else if (item is ConstructorParameter)
                    members.Add(new InjectionConstructor(item.Value));
                else if (item is ConstructorParameter[])
                    members.AddRange((item as ConstructorParameter[]).Select(data => new InjectionConstructor(data.Value)));
            });
            var lifetimeManager = injectionMembers.OfType<LifetimeManager>().FirstOrDefault();
 
            if (lifetimeManager == null && injectionMembers == null)
                Current.RegisterType(type);
            else if (lifetimeManager == null)
                Current.RegisterType(type, members.ToArray());
            else if (injectionMembers == null)
                Current.RegisterType(type, lifetimeManager);
            else
                Current.RegisterType(type, lifetimeManager, members.ToArray());
        }
 
        /// <summary>
        /// 注册类型
        /// </summary>
        /// <param name="type"></param>
        /// <param name="injectionMembers"></param>
        /// <param name="name"></param>
        public static void RegisterType(string name, Type type, params dynamic[] injectionMembers)
        {
            var members = new List<InjectionMember>();
            LinqExtensions.ForEach(injectionMembers, item =>
            {
                if (item is InjectionMember)
                    members.Add(item);
                if (item is InjectionMember[])
                    members.AddRange(item);
                else if (item is ConstructorParameter)
                    members.Add(new InjectionConstructor(item.Value));
                else if (item is ConstructorParameter[])
                    members.AddRange((item as ConstructorParameter[]).Select(data => new InjectionConstructor(data.Value)));
            });
            var lifetimeManager = injectionMembers.OfType<LifetimeManager>().FirstOrDefault();
 
            if (string.IsNullOrEmpty(name))
            {
                if (lifetimeManager == null && injectionMembers == null)
                    Current.RegisterType(type);
                else if (lifetimeManager == null)
                    Current.RegisterType(type, members.ToArray());
                else if (injectionMembers == null)
                    Current.RegisterType(type, lifetimeManager);
                else
                    Current.RegisterType(type, lifetimeManager, members.ToArray());
            }
            else
            {
                if (lifetimeManager == null && injectionMembers == null)
                    Current.RegisterType(type, name);
                else if (lifetimeManager == null)
                    Current.RegisterType(type, name, members.ToArray());
                else if (injectionMembers == null)
                    Current.RegisterType(type, name, lifetimeManager);
                else
                    Current.RegisterType(type, name, lifetimeManager, members.ToArray());
            }
        }
 
 
 
        /// <summary>
        /// 创建实例
        /// </summary>
        /// <param name="source"></param>
        /// <returns></returns>
        public static object Resolve(Type source)
        {
            return Current.Resolve(source);
        }
 
        private static ConcurrentDictionary<string, Action<dynamic>> _handles = new ConcurrentDictionary<string, Action<dynamic>>();
 
        /// <summary>
        /// 当创建新实例时触发
        /// </summary>
        /// <param name="handler"></param>
        /// <returns></returns>
        public void OnCreation<T>(Action<T> handler)
        {
            _handles.TryAdd(typeof(T).FullName, item => handler(item.Data));
        }
 
        public static bool HasRegistered(Type type)
        {
            return Current.IsRegistered(type);
        }
 
        /// <summary>
        /// 创建泛型实例
        /// </summary>
        /// <returns></returns>
        public static T Resolve<T>()
        {
            var result = Current.Resolve<T>();
            Action<dynamic> handler;
            if (_handles.TryGetValue(typeof(T).FullName, out handler))
            {
                handler(new EventArgs<T>(result));
            }
            return result;
        }
 
        /// <summary>
        /// 创建泛型实例
        /// </summary>
        /// <returns></returns>
        public static T Resolve<T>(string name)
        {
            return Current.Resolve<T>(name);
        }
 
        /// <summary>
        /// 创建泛型实例集合
        /// </summary>
        /// <returns></returns>
        public static T[] ResolveAll<T>()
        {
            var serviceImpls = Current.ResolveAll<T>();
            List<T> proxiedServiceImpls = new List<T>();
            foreach (var serviceImpl in serviceImpls)
            {
                Action<dynamic> handler;
                if (_handles.TryGetValue(typeof(T).FullName, out handler))
                {
                    handler(new EventArgs<T>(serviceImpl));
                }
                proxiedServiceImpls.Add(serviceImpl);
            }
 
            return proxiedServiceImpls.ToArray();
        }
 
        public static void Release(object obj)
        {
            Current.Teardown(obj);
        }
    }
}

辅助类

using System;
 
namespace Coralcode.Framework.Aspect
{
    [AttributeUsage(AttributeTargets.Class, AllowMultiple = true)]
    public class InjectAttribute : Attribute
    {
        /// <summary>
        /// 注册的名字
        /// </summary>
        public string Name { get; set; }
 
        /// <summary>
        /// 依赖注入的类型
        /// </summary>
        public Type RegisterType { get; set; }
 
        /// <summary>
        /// 注册条件
        /// </summary>
        public RegisterCondition Condition { get; set; }
 
        /// <summary>
        /// aop类型
        /// </summary>
        public AopType AopType { get; set; }
 
        /// <summary>
        /// 生命周期类型
        /// </summary>
        public LifetimeManagerType LifetimeManagerType { get; set; }
    }
 
    [Flags]
    public enum RegisterCondition
    {
        /// <summary>
        /// 是否必须
        /// </summary>
        IsRequire = 1,
    }
 
    /// <summary>
    /// 拦截类型
    /// </summary>
    public enum AopType
    {
        /// <summary>
        /// 不拦截
        /// </summary>
        None,
        /// <summary>
        /// 虚方法拦截
        /// </summary>
        VirtualMethodInterceptor,
        /// <summary>
        /// 接口拦截
        /// </summary>
        InterfaceInterceptor,
        /// <summary>
        /// 动态代理拦截
        /// </summary>
        TransparentProxyInterceptor,
        //这里可以添加自定义
    }
 
    public enum LifetimeManagerType
    {
        /// <summary>
        /// 每次通过Resolve或ResolveAll调用对象的时候都会重新创建一个新的对象。
        /// </summary>
        Transient,
        /// <summary>
        /// 容器控制生命周期管理，这个生命周期管理器是RegisterInstance默认使用的生命周期管理器，也就是单件实例
        /// </summary>
        ContainerControlled,
        /// <summary>
        /// 分层生命周期管理器，这个管理器类似于ContainerControlledLifetimeManager，
        /// 也是由UnityContainer来管理，也就是单件实例。
        /// 不过与ContainerControlledLifetimeManager不 同的是，
        /// 这个生命周期管理器是分层的，
        /// 因为Unity的容器时可以嵌套的，所以这个生命周期管理器就是针对这种情况，
        /// 当使用了这种生命周期管理器，
        /// 父容器 和子容器所维护的对象的生命周期是由各自的容器来管理
        /// </summary>
        Hierarchica,
        /// <summary>
        /// 外部控制生命周期管理器，这个 生命周期管理允许你使用RegisterType和RegisterInstance来注册对象之间的关系，
        /// 但是其只会对对象保留一个弱引用，
        /// 其生命周期 交由外部控制，也就是意味着你可以将这个对象缓存或者销毁而不用在意UnityContainer，
        /// 而当其他地方没有强引用这个对象时，其会被GC给销毁 掉。
        /// </summary>
        Externally,
        /// <summary>
        /// 每线程生命周期管理器，就是保证每个线程返回同一实例
        /// </summary>
        PerThread,
        /// <summary>
        /// 其类似于 TransientLifetimeManager，但是其不同在于，
        /// 如果应用了这种生命周期管理器，
        /// 则在第一调用的时候会创建一个新的对象，
        /// 而再次通过 循环引用访问到的时候就会返回先前创建的对象实例（单件实例），
        /// </summary>
        PerResolve,
    }<br>}

Aop辅助类

using System;
using Microsoft.Practices.Unity;
using Microsoft.Practices.Unity.InterceptionExtension;
 
namespace Coralcode.Framework.Aspect.Unity
{
    [AttributeUsage(AttributeTargets.Method|AttributeTargets.Class|AttributeTargets.Interface)]
    public abstract class UnityAopAttribute : HandlerAttribute, ICallHandler, IInterceptionBehavior
    {
        public override ICallHandler CreateHandler(IUnityContainer container)
        {
            return this;
        }
 
        public System.Collections.Generic.IEnumerable<Type> GetRequiredInterfaces()
        {
            return Type.EmptyTypes;
        }
 
        /// <summary>
        /// 调用之后的实现逻辑
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        protected virtual void OnAfter(IMethodInvocation input)
        {
             
        }
 
 
        /// <summary>
        /// 调用之前的实现逻辑
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        protected virtual void OnBefore(IMethodInvocation input)
        {
             
        }
 
        /// <summary>
        /// 调用出现异常的实现逻辑
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        protected virtual void OnException(IMethodInvocation input, Exception ex)
        {
            throw ex;
        }
 
        /// <summary>
        /// 接口注入时候的拦截方法
        /// </summary>
        /// <param name="input"></param>
        /// <param name="nextMethod"></param>
        /// <returns></returns>
        public IMethodReturn Invoke(IMethodInvocation input, GetNextHandlerDelegate nextMethod)
        {
            OnBefore(input);
            IMethodReturn result = null;
            try
            {
                result = nextMethod()(input, nextMethod);
            }
            catch (Exception ex)
            {
                OnException(input, ex);
            }
            OnAfter(input);
            return result;
        }
 
        /// <summary>
        /// 虚方法注入的拦截方法
        /// </summary>
        /// <param name="input"></param>
        /// <param name="nextMethod"></param>
        /// <returns></returns>
        public IMethodReturn Invoke(IMethodInvocation input, GetNextInterceptionBehaviorDelegate nextMethod)
        {
            OnBefore(input);
            IMethodReturn result=null;
            try
            {
               result = nextMethod()(input, nextMethod);
            }
            catch (Exception ex)
            {
                OnException(input, ex);
            }
            OnAfter(input);
            return result;
        }
 
        public bool WillExecute
        {
            get { return true; }
        }
    }
}

得益于Mvc的filter，实际项目中很少用到AOP,如果需要使用继承自这个类并标记在需要拦截的地方即可

EventBus

这里EventBus参考Abp和ApWorks的设计，这个发送的不算领域事件，是应用层
事件，在我项目中Event主要使用在三个地方
>* 统计模块预定事件以后可以根据设计好的查询需求去存放数据
这样会比原来从原始表中load数据快很多.
>* 在比如菜单中可以注册类型的事件实现菜单的动态修改。
这个会在做界面层的时候提到
>* 缓存数据的即时更新

分类: CRUD全栈式编程架构