转自：https://www.cnblogs.com/neverc/p/5241466.html

AOP介绍

面向切面编程（Aspect Oriented Programming,英文缩写为AOP），通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。

AOP是OOP的延续，是软件开发中的一个热点.

常用于：

Authentication

Caching

Lazy loading

Transactions

AOP基本原理

普通类

1
2
3
4
5
6
7
8
9
class Person : MarshalByRefObject
{
    public string Say()
    {
        const string str = "Person's say is called";
        Console.WriteLine(str);
        return str;
    }
}

代理类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Proxy<T> : RealProxy where T : new()
{
    private object _obj;
    public Proxy(object obj)
        : base(typeof(T))
    {
        _obj = obj;
    }
    public override IMessage Invoke(IMessage msg)
    {
        Console.WriteLine("{0}:Invoke前", DateTime.Now);
        var ret = ((IMethodCallMessage)msg).MethodBase.Invoke(_obj, null);
        Console.WriteLine("{0}:Invoke后", DateTime.Now);
        return new ReturnMessage(ret, null, 0, null, null);
    }
}

执行

1
2
3
4
5
6
7
8
9
10
static void Main(string[] args)
{
    var per = new Proxy<Person>(new Person()).GetTransparentProxy() as Person;
    if (per != null)
    {
        var str = per.Say();
        Console.WriteLine("返回值:" + str);
    }
    Console.ReadKey();
}

AOP框架

AOP有动态代理和静态IL织入.

本节主要介绍动态代理方式,静态可参考PostSharp.

Castle Core

原理:本质是创建继承原来类的代理类.重写虚方法实现AOP功能.

只需引用:

Install-Package Castle.Core

(在Castle的2.5以上版本，已经将 Castle.DynamicProxy2.dll 里有内容，集成到 Castle.Core.dll 中。)

Simple Class

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public abstract class Person
{
    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");
    }
}

interceptor

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class SimpleInterceptor : StandardInterceptor
{
    protected override void PreProceed(IInvocation invocation)
    {
        Console.WriteLine("拦截器调用方法前，方法名是：{0}。", invocation.Method.Name);
    }
 
    protected override void PerformProceed(IInvocation invocation)
    {
        Console.WriteLine("拦截器开始调用方法，方法名是：{0}。", invocation.Method.Name);
        var attrs = invocation.MethodInvocationTarget.Attributes.HasFlag(MethodAttributes.Abstract);//过滤abstract方法
        if (!attrs)
        {
            base.PerformProceed(invocation);//此处会调用真正的方法 invocation.Proceed();
        }
    }
 
    protected override void PostProceed(IInvocation invocation)
    {
        Console.WriteLine("拦截器调用方法后，方法名是：{0}。", invocation.Method.Name);
    }
}

Main

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
static void Main(string[] args)
{
    var generator = new ProxyGenerator();       //实例化【代理类生成器】 
    var interceptor = new SimpleInterceptor();  //实例化【拦截器】 
 
    //使用【代理类生成器】创建Person对象，而不是使用new关键字来实例化 
    var person = generator.CreateClassProxy<Person>(interceptor);
 
    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();
 
}

Castle Windsor

特性式AOP

1
2
3
4
5
6
7
8
9
10
11
12
13
public interface IPerson
{
    void Say();
}
 
[Interceptor(typeof(LogInterceptor))]
public class Person : IPerson
{
    public void Say()
    {
        Console.WriteLine("Person's Say Method is called!");
    }
}
1
2
3
4
5
6
7
8
9
public class LogInterceptor : IInterceptor
{
    public void Intercept(IInvocation invocation)
    {
        Console.WriteLine("{0}:拦截{1}方法{2}前,", DateTime.Now.ToString("O"), invocation.InvocationTarget.GetType().BaseType, invocation.Method.Name);
        invocation.Proceed();
        Console.WriteLine("{0}:拦截{1}方法{2}后,", DateTime.Now.ToString("O"), invocation.InvocationTarget.GetType().BaseType, invocation.Method.Name);
    }
}
1
2
3
4
5
6
7
8
9
10
11
static void Main(string[] args)
{
    using (var container = new WindsorContainer())
    {
        container.Register(Component.For<Person, IPerson>());
        container.Register(Component.For<LogInterceptor, IInterceptor>());
        var person = container.Resolve<IPerson>();
        person.Say();
    }
    Console.ReadKey();
}

非侵入式AOP

1
2
3
4
5
6
7
8
9
10
11
12
public interface IPerson
{
    void Say();
}
 
public class Person : IPerson
{
    public void Say()
    {
        Console.WriteLine("Person's Say Method is called!");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
internal static class LogInterceptorRegistrar
{
    public static void Initialize(WindsorContainer container)
    {
        container.Kernel.ComponentRegistered += Kernel_ComponentRegistered;
    }
 
    private static void Kernel_ComponentRegistered(string key, IHandler handler)
    {
        handler.ComponentModel.Interceptors.Add(new InterceptorReference(typeof(LogInterceptor)));
    }
}
public class LogInterceptor : IInterceptor
{
    public void Intercept(IInvocation invocation)
    {
        Console.WriteLine("{0}:拦截{1}方法{2}前,", DateTime.Now.ToString("O"), invocation.InvocationTarget.GetType().BaseType, invocation.Method.Name);
        invocation.Proceed();
        Console.WriteLine("{0}:拦截{1}方法{2}后,", DateTime.Now.ToString("O"), invocation.InvocationTarget.GetType().BaseType, invocation.Method.Name);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
static void Main(string[] args)
{
    using (var container = new WindsorContainer())
    {
        container.Register(Component.For<IInterceptor, LogInterceptor>());//先注入拦截器
        LogInterceptorRegistrar.Initialize(container);
        container.Register(Component.For<IPerson, Person>());
        var person = container.Resolve<IPerson>();
        person.Say();
    }
    Console.ReadKey();
}

Autofac

Install-Package Autofac.Aop

通过特性标签绑定

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class LogInterceptor : IInterceptor
 {
     public void Intercept(IInvocation invocation)
     {
         Console.WriteLine("{0}:拦截{1}方法{2}前,", DateTime.Now.ToString("O"), invocation.InvocationTarget.GetType().BaseType, invocation.Method.Name);
         invocation.Proceed();
         Console.WriteLine("{0}:拦截{1}方法{2}后,", DateTime.Now.ToString("O"), invocation.InvocationTarget.GetType().BaseType, invocation.Method.Name);
     }
 }
 
 public interface IPerson
 {
     void Say();
 }
 
 [Intercept(typeof(LogInterceptor))]
 public class Person : IPerson
 {
     public void Say()
     {
         Console.WriteLine("Person's Say Method is called!");
     }
 }

启用拦截器执行

1
2
3
4
5
6
7
8
9
10
11
static void Main(string[] args)
{
    var builder = new ContainerBuilder();
    builder.RegisterType<Person>().As<IPerson>().EnableInterfaceInterceptors();
    builder.RegisterType<LogInterceptor>();
    using (var container = builder.Build())
    {
        container.Resolve<IPerson>().Say();
    }
    Console.ReadLine();
}

或采用非侵入性方法(去掉class上的特性仍可以)

1
2
3
4
5
6
7
8
9
10
11
static void Main(string[] args)
{
    var builder = new ContainerBuilder();
    builder.RegisterType<Person>().As<IPerson>().EnableInterfaceInterceptors().InterceptedBy(typeof(LogInterceptor));
    builder.RegisterType<LogInterceptor>();
    using (var container = builder.Build())
    {
        container.Resolve<IPerson>().Say();
    }
    Console.ReadLine();
}

　　

Unity

Unity默认提供了三种拦截器：TransparentProxyInterceptor、InterfaceInterceptor、VirtualMethodInterceptor。

TransparentProxyInterceptor：代理实现基于.NET Remoting技术，它可拦截对象的所有函数。缺点是被拦截类型必须派生于MarshalByRefObject。

InterfaceInterceptor：只能对一个接口做拦截，好处时只要目标类型实现了指定接口就可以拦截。

VirtualMethodInterceptor：对virtual函数进行拦截。缺点是如果被拦截类型没有virtual函数则无法拦截，这个时候如果类型实现了某个特定接口可以改用

Install-Package Unity.Interception

1
2
3
4
5
6
7
8
9
10
11
12
13
public class MyHandler : ICallHandler
{
    public int Order { get; set; }//这是ICallHandler的成员，表示执行顺序
    public IMethodReturn Invoke(IMethodInvocation input, GetNextHandlerDelegate getNext)
    {
        Console.WriteLine("方法执行前");
        //这之前插入方法执行前的处理
        var retvalue = getNext()(input, getNext);//在这里执行方法
        //这之后插入方法执行后的处理
        Console.WriteLine("方法执行后");
        return retvalue;
    }
}
1
2
3
4
5
6
7
public class MyHandlerAttribute : HandlerAttribute
{
    public override ICallHandler CreateHandler(IUnityContainer container)
    {
        return new MyHandler();//返回MyHandler
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
public interface IPerson
{
    void Say();
}
 
[MyHandler]
public class Person : IPerson
{
    public virtual void Say()
    {
        Console.WriteLine("Person's Say Method is called!");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
static void Main(string[] args)
{
    using (var container = new UnityContainer())
    {
        container.AddNewExtension<Interception>();
        //1.TransparentProxyInterceptor
        //container.Configure<Interception>().SetInterceptorFor<IPerson>(new TransparentProxyInterceptor());
 
        //2.InterfaceInterceptor (使用1,2,3均可,这种侵入性最小)
        container.Configure<Interception>().SetInterceptorFor<IPerson>(new InterfaceInterceptor());
 
        //3.VirtualMethodInterceptor
        //container.Configure<Interception>().SetInterceptorFor<Person>(new VirtualMethodInterceptor());
        container.RegisterType<IPerson, Person>();
        container.Resolve<IPerson>().Say();
    }
    Console.ReadKey();
}

AOP原理解析及Castle、Autofac、Unity框架使用的更多相关文章

  1. [Solution] DI原理解析及Castle、Unity框架使用

    本节目录 DI介绍 DI基本原理 DI框架 Castle Windsor Unity Autofac Spring.Net DI介绍 控制反转(Inversion of Control,英文缩写为Io ...

  2. [Solution] AOP原理解析及Castle、Autofac、Unity框架使用

    本节目录: AOP介绍 AOP基本原理 AOP框架 Castle Core Castle Windsor Autofac Unity AOP介绍 面向切面编程(Aspect Oriented Prog ...

  3. Spring笔记(3) - debug源码AOP原理解析

    案例 @EnableAspectJAutoProxy//开启基于注解的aop模式 @Configuration public class AOPConfig { //业务逻辑类加入容器中 @Bean ...

  4. Spring AOP原理解析

    原文链接请参见:http://blog.csdn.net/u010723709/article/details/47839307

  5. [置顶] 滴滴插件化框架VirtualAPK原理解析（一）之插件Activity管理

    上周末,滴滴与360都开源了各自的插件化框架,VirtualAPK与RePlugin,作为一个插件化方面的狂热研究者,在周末就迫不及待的下载了Virtualapk框架来进行研究,本篇博客带来的是Vir ...

  6. ABP中动态WebAPI原理解析

    ABP中动态WebAPI原理解析 动态WebAPI应该算是ABP中最Magic的功能之一了吧.开发人员无须定义继承自ApiController的类,只须重用Application Service中的类 ...

  7. SSH深度历险（十） AOP原理及相关概念学习+AspectJ注解方式配置spring AOP

    AOP(Aspect Oriented Programming),是面向切面编程的技术.AOP基于IoC基础,是对OOP的有益补充. AOP之所以能得到广泛应用,主要是因为它将应用系统拆分分了2个部分 ...

  8. Spring IOC设计原理解析:本文乃学习整理参考而来

    Spring IOC设计原理解析:本文乃学习整理参考而来 一. 什么是Ioc/DI? 二. Spring IOC体系结构 (1) BeanFactory (2) BeanDefinition 三. I ...

  9. Spring源码分析之AOP从解析到调用

    正文: 在上一篇,我们对IOC核心部分流程已经分析完毕,相信小伙伴们有所收获,从这一篇开始,我们将会踏上新的旅程,即Spring的另一核心:AOP! 首先,为了让大家能更有效的理解AOP,先带大家过一 ...

随机推荐

  1. **Python中的深拷贝和浅拷贝详解

    Python中的深拷贝和浅拷贝详解   这篇文章主要介绍了Python中的深拷贝和浅拷贝详解,本文讲解了变量-对象-引用.可变对象-不可变对象.拷贝等内容.   要说清楚Python中的深浅拷贝,需要 ...

  2. django -- 内置分页

    urls.py from django.conf.urls import url from conn_oracle import views urlpatterns = [ url(r'^page/' ...

  3. vue 起步_code

    <template> <div class="hello"> <h1>{{ msg }}</h1> <div>{{dat ...

  4. 塔防游戏 Day3

    1. 添加按钮动画 选择 Button->Transition 为 Animation ,然后自定义四种状态动画即可. 2. 控制升级面板的显示和隐藏 // 升级处理 // 若点击同一炮塔,并且 ...

  5. HTTP 1.0 & 1.1

    简介: HTTP ( HyperText Transfer Protocol ) 超文本传输协议,是互联网上应用最广泛的一种网络协议. HTTP 是一个客户端和服务端请求.应答的标准.使用 WEB 浏 ...

  6. Hash表从了解到深入（浅谈）

    · Hasn表,将一个数据进行Value化,再进行一个映射关系到Key直接进行访问的一个数据结构,这样可以通过直接的计算进行数据的访问和插入.关于Hash表的基本概念这里就不一一叙述,可以通过百度了解 ...

  7. 求Half向量

    [求Half向量] 给定入射向量与视角向量.把入射向量与视角向量相加即可,如下: 前提是 lightDir.ViewDir 都是单位向量.

  8. css实现文本过长时自动添加省略号

    1. 效果 2. Html <div id="main_app_content" class="container"> <div class= ...

  9. 游戏动作师使用Unity3D遇到过的所有问题

    http://blog.csdn.net/onafioo/article/details/50865169 http://www.gameres.com/thread_480489.html 文/拉撒 ...

  10. 规范抢先看！微信小程序的官方设计指南和建议

    基于微信小程序轻快的特点,我们(微信官方)拟定了小程序界面设计指南和建议. 设计指南建立在充分尊重用户知情权与操作权的基础之上.旨在微信生态体系内,建立友好.高效.一致的用户体验,同时最大程度适应和支 ...