Install-Package Castle.Core -Version 3.3.

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

//先在Nuget上搜索Castle安装

using Castle.DynamicProxy;

namespace CastleDEMO

{

    /// <summary>

    /// 拦截器 需要实现 IInterceptor接口 Intercept方法

    /// </summary>

    public class DA_LogInterceptor : IInterceptor

    {

        public void Intercept(IInvocation invocation)

        {

            try

            {

                DateTime begin = DateTime.Now;

                Console.WriteLine("开始DAL {0}调用!", invocation.Method.Name);

                //在被拦截的方法执行完毕后 继续执行

                invocation.Proceed();

                DateTime end = DateTime.Now;

                Console.WriteLine("结束DAL {0}调用!耗时:{1}ms", invocation.Method.Name, (end - begin).TotalMilliseconds);

            }

            catch (Exception ex)

            {

                string methodName = "DA_" + invocation.TargetType.ToString() + "." + invocation.Method.Name;

                Console.WriteLine("{0}方法错误：{1}", methodName, ex.Message);

                //如果没有定义异常处理返回值,就直接抛异常

                if (!invocation.Method.IsDefined(typeof(ExceptionReturnAttribute), false))

                    throw;

                var ls = invocation.Method.GetCustomAttributes(typeof(ExceptionReturnAttribute), false);

                if (null == ls || ls.Length <= )

                    throw;

                ExceptionReturnAttribute v = (ExceptionReturnAttribute)ls[];

                if (null == v.Value && null == v.Type)

                {

                    invocation.ReturnValue = null;

                    return;

                }

                if (null != v.Value)

                {

                    invocation.ReturnValue = v.Value;

                    return;

                }

                if (null != v.Type)

                {

                    invocation.ReturnValue = Activator.CreateInstance(v.Type);

                    return;

                }

            }

        }

        /// <summary>

        /// <para>DAO层异常时，不throw，返回设定的值.</para>

        /// <para>1. 返回复杂类型，使用Type，复杂类型需要有无参的构造函数</para>

        /// <para>2. 返回简单类型，使用value</para>

        /// </summary>

        [AttributeUsage(AttributeTargets.Method)]

        public class ExceptionReturnAttribute : System.Attribute

        {

            /// <summary>

            /// 返回复杂类型，使用Type，复杂类型需要有无参的构造函数

            /// </summary>

            public Type Type { get; set; }

            /// <summary>

            /// 返回简单类型，使用value

            /// </summary>

            public object Value { get; set; }

        }

    }

}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using Castle.DynamicProxy;

namespace CastleDEMO

{

    /// <summary>

    /// Dao 类的接口

    /// 继承实现BaseDao的类,其相关接口访问的公共方法必须要声明 virtual 方法才能被拦截器拦截。

    /// </summary>

    public abstract class BaseDao

    {

    }

    /// <summary>

    /// Dao容器,必须依赖于此类来创建Dao对象，使Dao受控，可进行检查等

    /// </summary>

    public class DaoContainer

    {

        //ProxyGenerator上自身有缓存

        //实例化【代理类生成器】

        public static ProxyGenerator generator = new ProxyGenerator();

        public static T GetDao<T>() where T : BaseDao

        {

            //实例化【拦截器】

            DA_LogInterceptor interceptor = new DA_LogInterceptor();

            //使用【代理类生成器】创建T对象，而不是使用new关键字来实例化

            return generator.CreateClassProxy<T>(interceptor);

        }

    }

}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace CastleDEMO

{

    public abstract class PersonDAL : BaseDao

    {

        /// <summary>

        /// 必须是虚方法才能被拦截器拦截

        /// </summary>

        public virtual void SayHello()

        {

            Console.WriteLine("我是虚方法{0}方法", "SayHello");

        }

        public virtual void SayName(string name)

        {

            Console.WriteLine("我是虚方法{0}方法,参数值:{1}", "SayName", name);

        }

        public abstract void AbstactSayOther();

        public void SayOther()

        {

            Console.WriteLine("我是普通方法{0}方法", "SayOther");

        }

    }

}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace CastleDEMO

{

    public class Program

    {

        public static void Main(string[] args)

        {

            PersonDAL person = DaoContainer.GetDao<PersonDAL>();

            Console.WriteLine("当前类型:{0},父类型:{1}", person.GetType(), person.GetType().BaseType);

            Console.WriteLine();

            person.SayHello();//拦截

            Console.WriteLine();

            person.SayName("Never、C");//拦截

            Console.WriteLine();

            person.SayOther();//普通方法,无法拦截

            //person.AbstactSayOther();//抽象方法,可以拦截（但是如果方法没实现拦截时会报错）

            Console.ReadLine();

        }

    }

}