使用Unity2.0的Interceptor实现简单AOP

        Unity 2.0 现在已经是Enterprise Library 中一个模块了。我们可以使用Unity 2.0的Interceptor来拦截方法最终实现AOP。它的实现是这样的,看下面的图比较清楚：

 

        让我们看下面的DEMO代码:

    public interface IDAL
    {
        void MethodForLoggingA();
        void MethodForLoggingB();
        void MethodForLoggingC(int num);
    }

       实现类:

    public class DAL : IDAL
    {
        public virtual void MethodForLoggingA()
        {
            Console.WriteLine("Called MethodForLoggingA");
        }
        public virtual void MethodForLoggingB()
        {
            Console.WriteLine("Called MethodForLoggingB");
        }
        public virtual  void MethodForLoggingC(int num)
        {
            Console.WriteLine("Called MethodForLoggingC {0}", num);
        }
    }

       让我们来写一个自定义拦截行为，我们需要继承自这个IInterceptionBehavior，假设我们要记录方法调用的全过程。

    public class MyInterceptor : IInterceptionBehavior
    {
        public IEnumerable<Type> GetRequiredInterfaces()
        {
            return Type.EmptyTypes;
        }

        public IMethodReturn Invoke(IMethodInvocation input, GetNextInterceptionBehaviorDelegate getNext)
        {
            /* Call the method that was intercepted */
            string className = input.MethodBase.DeclaringType.Name;
            string methodName = input.MethodBase.Name;
            string generic = input.MethodBase.DeclaringType.IsGenericType ? string.Format("<{0}>", input.MethodBase.DeclaringType.GetGenericArguments().ToStringList()) : string.Empty;
            string arguments = input.Arguments.ToStringList();

            string preMethodMessage = string.Format("{0}{1}.{2}({3})", className, generic, methodName, arguments);
            Console.WriteLine("PreMethodCalling: " + preMethodMessage);
            //Logging
            Logger.Instance.Log(preMethodMessage);
            //Invoke method
            IMethodReturn msg = getNext()(input, getNext);
            //Post method calling
            string postMethodMessage = string.Format("{0}{1}.{2}() -> {3}", className, generic, methodName, msg.ReturnValue);
            Console.WriteLine("PostMethodCalling: " + postMethodMessage);
            //Logging
            Logger.Instance.Log(postMethodMessage);
            return msg;
        }

        public bool WillExecute
        {
            get { return true; }
        }
    }

    public class Logger
    {
        private static Logger _instance = new Logger();
        public static Logger Instance { get { return _instance; } }
        public void Log(string message)
        {
            //logging code
        }
    }

    public static class EnumerableExtensions
    {
        public static string ToStringList(this IEnumerable list)
        {
            StringBuilder sb = new StringBuilder();

            foreach (var item in list)
            {
                sb.AppendFormat("{0}, ", item);
            }
            if (sb.Length > 0)
                sb.Remove(sb.Length - 2, 2);

            return sb.ToString();
        }
    }

客户端的代码是这样的：

        static void Main(string[] args)
        {
            IUnityContainer container = new UnityContainer();
            container.AddNewExtension<Interception>();
            container.RegisterType<IDAL, DAL>(
            //only block virtual method
            new Interceptor<VirtualMethodInterceptor>(),
              //new Interceptor<InterfaceInterceptor>(),
              //new Interceptor<TransparentProxyInterceptor>(),
            new InterceptionBehavior<MyInterceptor>()
            );

            var dal = container.Resolve<IDAL>();

            dal.MethodForLoggingA();

            dal.MethodForLoggingB();

            dal.MethodForLoggingC(8);

            Console.Read();

        }

   对于上面这个DEMO，Unity提供的三个拦截器我们都可以使用。但注意 VirtualMethodInterceptor 只能对虚方法拦截。它们之间优缺点看下表（msdn）：

Type	Advantages	Disadvantages
Transparent Proxy Interceptor	Can intercept all methods of the target object (virtual, non-virtual, or interface).	The object must either implement an interface or inherit from System.MarshalByRefObject. If the marshal by reference object is not a base class, you can only proxy interface methods. The Transparent Proxy process is much slower than a regular method call.
Interface Interceptor	Allows interception on any object that implements the target interface. It is much faster than the TransparentProxyInterceptor.	It only intercepts methods on a single interface. It cannot cast a proxy back to the target object's class or to other interfaces on the target object.
Virtual Method Interceptor	Calls are much faster than the Transparent Proxy Interceptor.	Interception only happens on virtual methods. You must set up interception at object creation time and cannot intercept an existing object.

   所以，你有注意到我们DAL中的三个方法都是virtual。最后输出：

PreMethodCalling: DAL.MethodForLoggingA()
Called MethodForLoggingA
PostMethodCalling: DAL.MethodForLoggingA() ->
PreMethodCalling: DAL.MethodForLoggingB()
Called MethodForLoggingB
PostMethodCalling: DAL.MethodForLoggingB() ->
PreMethodCalling: DAL.MethodForLoggingC(8)
Called MethodForLoggingC 8
PostMethodCalling: DAL.MethodForLoggingC() –>

   您可以对篇文章也感兴趣：

   使用EnterpriseLibrary的PIAB与Unity搭建简单AOP框架

   希望这篇POST对您开发有帮助。

作者：Petter Liu
出处：http://www.cnblogs.com/wintersun/
本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。
该文章也同时发布在我的独立博客中-Petter Liu Blog。