第四节 Autofac面向切面编程

AOP介绍
AOP面向切面编程，可以说是OOP面向对象编程的补充和完善。

面向切面编程，就是将交叉业务逻辑封装成切面，利用AOP的功能将切面织入到主业务逻辑中。所谓交叉业务逻辑是指，通用的，与主业务逻辑无关的代码，如安全检查，事物，日志等。若不使用AOP，则会出现代码纠缠，即交叉业务逻辑与主业务逻辑混合在一起。这样，会使业务逻辑变得混杂不清。

nugut下载

基于Autofac的面向切面编程例子：

using Autofac;
using Autofac.Extras.DynamicProxy;
using Castle.DynamicProxy;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Xml.Serialization;

namespace ConsoleApplication1
{
    public class LogInterceptor : IInterceptor
    {
        public void Intercept(IInvocation invocation)
        {
            //方法执行前
            string beforeExe_msg = string.Format("方法执行前:拦截[{0}]类下的方法[{1}]的参数是[{2}]",
                invocation.InvocationTarget.GetType(), invocation.Method.Name, string.Join(", ", invocation.Arguments.Select(a => (a ?? "").ToString()).ToArray()));

            Console.WriteLine(beforeExe_msg);

            //方法执行
            invocation.Proceed();

            //方法执行完成后
            string afterExe_msg = string.Format("方法执行完毕，返回结果：{0}", invocation.ReturnValue);
            Console.WriteLine(afterExe_msg);
        }
    }

    [Intercept(typeof(LogInterceptor))] // Person 使用 LogInterceptor拦截器
    public class Person
    {
        public virtual int MethodHA(string a, string b)//Pay Attention : 一定要用虚函数!!!!!!!!!!
        {
            Console.WriteLine("第一个参数：" + a + "    第二个参数：" + b);
            return Convert.ToInt32(a) + Convert.ToInt32(b);
        }
    }

    class Program
    {
        private static IContainer Container { get; set; }
        static void Main(string[] args)
        {
            var builder = new ContainerBuilder();
            builder.RegisterType<LogInterceptor>(); // 注册拦截器
            builder.RegisterType<Person>().EnableClassInterceptors();  // 注册被拦截的类并启用类拦截
            Container = builder.Build();

            using (var scope = Container.BeginLifetimeScope())
            {
                var person = scope.Resolve<Person>();
                for (int i = 0; i < 2; i++)
                {
                    person.MethodHA((i + 11).ToString(), (i * 22).ToString());
                }
            }

            Console.ReadLine();
        }
    }
}

执行结果

下面是通过接口的方式注册 其实都差不多

    //public interface IPerson
    //{
    //    void Method();
    //}

    //[Intercept(typeof(LogInterceptor))] // Person 使用 LogInterceptor拦截器
    //public class Person : IPerson
    //{
    //    public void Method()
    //    {
    //        Console.WriteLine("Method2");
    //    }
    //}

    //class Program
    //{
    //    private static IContainer Container { get; set; }
    //    static void Main(string[] args)
    //    {
    //        var containerBuilder = new ContainerBuilder();
    //        containerBuilder.RegisterType<LogInterceptor>();
    //        containerBuilder.RegisterType<Person>().As<IPerson>().EnableInterfaceInterceptors();
    //        Container = containerBuilder.Build();

    //        using (var scope = Container.BeginLifetimeScope())
    //        {
    //            var person = scope.Resolve<IPerson>();
    //            person.Method();
    //        }

    //        Console.ReadLine();
    //    }
    //}