动态方法与动态代理(下篇)

动态代理：

　　代理模式和装饰模式的区别：

　　装饰模式：在不改变接口的前提下，动态扩展对象的功能

      代理模式：在不改变接口的前提下，控制对象的访问

      代理类和被代理对象是has-a关系，一般没有is-a关系，除非代理类直接继承被代理类，重写被代理类的方法

动态代理是指通过动态代码技术在运行时生成具体类的代理，目的是在执行具体类的操作之前或之后运行特定的逻辑

动态代理既可以代理类也可以代理接口，代理类时，被代理的类不能为Sealed，并且其中属性和方法都必须为Virtual，而代理接口时则无约束条件

 •Demo：动态生成接口的代理

  1  public interface ICalculate
  2     {
  3         void Add(int a, int b);
  4     }
  5 
  6     public class A : ICalculate
  7     {
  8         #region ICalculate 成员
  9 
 10         public void Add(int a, int b)
 11         {
 12             Console.WriteLine(a + b);
 13         }
 14 
 15         #endregion
 16     }
 17 
 18     public class B : ICalculate
 19     {
 20         ICalculate _inst;
 21 
 22         public B(ICalculate o)
 23         {
 24             _inst = o;
 25         }
 26 
 27         #region ICalculate 成员
 28 
 29         public void Add(int a, int b)
 30         {
 31             Console.WriteLine("Before...");
 32             _inst.Add(a, b);
 33             Console.WriteLine("After...");
 34         }
 35 
 36         #endregion
 37     }
 38 
 39     class Program
 40     {
 41         static void Main(string[] args)
 42         {
 43             Type proxyType;//代理类型
 44 
 45             #region Emit Class
 46 
 47             AssemblyName assemblyName = new AssemblyName("DynamicAssemblyExample");
 48             AssemblyBuilder assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.RunAndSave);
 49             ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule(assemblyName.Name, assemblyName.Name + ".dll");
 50 
 51             TypeBuilder typeBuilder = moduleBuilder.DefineType("DynamicAssemblyExample.Calculate", TypeAttributes.Public | TypeAttributes.Class
 52                 , typeof(object), new Type[] { typeof(ICalculate) });
 53 
 54             FieldBuilder instanceField = typeBuilder.DefineField("_instance", typeof(ICalculate), FieldAttributes.Private);
 55 
 56             ConstructorBuilder constructorBuilder = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, new Type[] { typeof(ICalculate) });
 57 
 58             ILGenerator ilGenConstructor = constructorBuilder.GetILGenerator();
 59             ilGenConstructor.Emit(OpCodes.Ldarg_0);
 60             ilGenConstructor.Emit(OpCodes.Call, typeof(object).GetConstructor(Type.EmptyTypes)); //base.ctor()
 61             ilGenConstructor.Emit(OpCodes.Ldarg_0);
 62             ilGenConstructor.Emit(OpCodes.Ldarg_1);
 63             ilGenConstructor.Emit(OpCodes.Stfld, instanceField);
 64             ilGenConstructor.Emit(OpCodes.Ret);
 65 
 66             MethodInfo addMethodInfo = typeof(ICalculate).GetMethod("Add");
 67 
 68             MethodAttributes methodAttr = addMethodInfo.Attributes & ~(MethodAttributes.Abstract);
 69 
 70             List<Type> paramTypes = new List<Type>();
 71 
 72             foreach (ParameterInfo pInfo in addMethodInfo.GetParameters())
 73             {
 74                 paramTypes.Add(pInfo.ParameterType);
 75             }
 76 
 77             MethodBuilder addMethod = typeBuilder.DefineMethod(addMethodInfo.Name, methodAttr,
 78                 CallingConventions.Standard, addMethodInfo.ReturnType, paramTypes.ToArray());
 79 
 80             //writeline call
 81             MethodInfo writeLineMethod = typeof(Console).GetMethod("WriteLine", new Type[] { typeof(string) });
 82 
 83             ILGenerator ilGenAddMethod = addMethod.GetILGenerator();
 84 
 85 
 86             ilGenAddMethod.Emit(OpCodes.Ldstr, "Before...");
 87             ilGenAddMethod.Emit(OpCodes.Call, writeLineMethod);
 88 
 89             //每个实例方法都默认包含一个隐藏的参数，即第0个参数，它对应的是this指针，但静态方法没有隐藏的第0个参数
 90             ilGenAddMethod.Emit(OpCodes.Ldarg_0);
 91             ilGenAddMethod.Emit(OpCodes.Ldfld, instanceField);
 92 
 93             
 94             ilGenAddMethod.Emit(OpCodes.Ldarg_1);//a
 95             ilGenAddMethod.Emit(OpCodes.Ldarg_2);//b
 96             ilGenAddMethod.Emit(OpCodes.Callvirt, typeof(ICalculate).GetMethod("Add"));//a+b
 97 
 98             ilGenAddMethod.Emit(OpCodes.Ldstr, "After...");
 99             ilGenAddMethod.Emit(OpCodes.Call, writeLineMethod);
100 
101             /*
102              * Console.WriteLine(this.GetType().FullName);
103              */
104             ilGenAddMethod.DeclareLocal(typeof(int));
105             ilGenAddMethod.Emit(OpCodes.Ldarg_0);
106             ilGenAddMethod.Emit(OpCodes.Callvirt, typeof(object).GetMethod("GetType"));
107             ilGenAddMethod.Emit(OpCodes.Callvirt, typeof(Type).GetMethod("get_FullName"));
108             ilGenAddMethod.Emit(OpCodes.Call, writeLineMethod);
109 
110 
111             ilGenAddMethod.Emit(OpCodes.Ret);
112 
113             proxyType = typeBuilder.CreateType();
114 
115             assemblyBuilder.Save("DynamicAssemblyExample.dll");
116             #endregion
117 
118             ICalculate proxyImp = (ICalculate)proxyType.GetConstructor(new Type[] { typeof(ICalculate) })
119                 .Invoke(new object[] { new A() });
120 
121             proxyImp.Add(10, 20);
122         }
123     }

 AOP的概念

　　•Aspect Oriented Programming

　　•AOP是OOP的延续，意思是面向切面编程

　　•切面是指整体中的某个行为（功能）部分

　　•目标：将与主逻辑无紧密关系的行为，从业务逻辑代码中分离出来

　　•优点：当改变某个行为时，不会影响到业务逻辑，并且使代码进一步解耦

　　•常用于日志记录，性能统计，安全控制，事务处理，异常处理等等

AOP的工作原理 

•AOP的关键是拦截正常的方法调用，即将需要额外附加的功能透明的“织入（ Weave）”到这些方法中

•所谓“织入”简单的讲就是指将附件功能和目标的原有功能融合在一起，AOP像一台织布机，将两者天衣无缝的编织起来，织入是透明的

•在.Net中，AOP的织入方式有两种：

   静态织入：在编译阶段将附加逻辑写入代码中

   动态织入：在运行阶段将附加逻辑写入代码中 

  •静态织入：一般都需要扩展编译器的功能，优点是代码执行的效率高，缺点是实现者需要对虚拟机有很深的了解，而且修改代码之后都需要重新编译，目前，最著名的产品是：PostSharp

  •动态织入：不需要扩展编译器的功能，优点是在运行时自动生成代码，缺点是执行效率不高，需要额外的开销，目前，运用动态织入方法的产品较多，Castle.DynamicProxy是其中的经典之一

   动态织入的实现技术就是动态代理，由于静态织入存在局限性，一般来说，AOP框架实现方式首选动态织入，因此，AOP可以看作是动态代理发展的产物

 •Demo：AOP实践Castle.DynamicProxy

这是一个轻量级的，能为一个或多个接口或具体类创建动态代理的类库，或者称之为AOP类库内部机制是使用反射发出动态织入
拦截器（ Interceptor）是其中的重要概念，用于截获方法的调用，增加新的逻辑，自定义拦截器必须实现IInterceptor接口或者继承内置的标准拦截器类StandardInterceptor拦截器对方法和属性都有效

典型应用：
   参数检验
   延迟加载（Lazy Loading）
典型代表：
   NHibernate

 1  class Program
 2     {
 3         static void Main(string[] args)
 4         {
 5             DemoClassInterceptorTest.DoTest();
 6 
 7             //DemoInterfaceInterceptorTest.DoTest();
 8         }
 9     }
10 public interface IDemoInterface
11     {
12         void Add(int a, int b);
13     }
14 
15     public class DemoInterfaceClass : IDemoInterface
16     {
17         #region DemoInterface 成员
18 
19         public void Add(int a, int b)
20         {
21             Console.WriteLine(a + b);
22         }
23 
24         #endregion
25     }
26 
27     public class DemoInterfaceInterceptor : StandardInterceptor
28     {
29         protected override void PreProceed(IInvocation invocation)
30         {
31             Console.WriteLine("PreProceed：{0}", invocation.Method.ToString());
32         }
33 
34         protected override void PostProceed(IInvocation invocation)
35         {
36             Console.WriteLine("PostProceed：{0}", invocation.Method.ToString());
37         }
38 
39         protected override void PerformProceed(IInvocation invocation)
40         {
41             base.PerformProceed(invocation);
42         }
43     }
44 
45     public class DemoInterfaceInterceptorTest
46     {
47         public static void DoTest()
48         {
49             DemoInterfaceClass realObj = new DemoInterfaceClass();
50 
51             DemoInterfaceInterceptor interceptor = new DemoInterfaceInterceptor();
52 
53             ProxyGenerator generator = new ProxyGenerator();
54             IDemoInterface proxy=generator.CreateInterfaceProxyWithTargetInterface<IDemoInterface>(realObj, interceptor);
55             proxy.Add(10, 50);
56         }
57     } 

 1  public class DemoClass
 2     {
 3 
 4         string _text;
 5         public virtual string Text
 6         {
 7             get
 8             {
 9                 return _text;
10             }
11             set
12             {
13                 _text = value;
14             }
15         }
16 
17         public virtual void Add(int a, int b)
18         {
19             Console.WriteLine(a + b);
20         }
21     }
22 
23     class DemoClassInterceptor : IInterceptor
24     {
25         #region IInterceptor 成员
26 
27         /// <summary>
28         /// Intercepts the specified invocation.
29         /// </summary>
30         /// <param name="invocation">The invocation.</param>
31         public void Intercept(IInvocation invocation)
32         {
33             PreProceed(invocation);
34             invocation.Proceed();
35             PostProceed(invocation);
36         }
37 
38         #endregion
39 
40         public void PreProceed(IInvocation invocation)
41         {
42             Console.WriteLine("PreProceed 1 代理了：{0}", invocation.Method.ToString());
43         }
44 
45         public void PostProceed(IInvocation invocation)
46         {
47             Console.WriteLine("PostProceed 1 代理了：{0}", invocation.Method.ToString());
48         }
49     }
50 
51     class DemoClassInterceptor2 : IInterceptor
52     {
53         #region IInterceptor 成员
54 
55         /// <summary>
56         /// Intercepts the specified invocation.
57         /// </summary>
58         /// <param name="invocation">The invocation.</param>
59         public void Intercept(IInvocation invocation)
60         {
61             PreProceed(invocation);
62             invocation.Proceed();
63             PostProceed(invocation);
64         }
65 
66         #endregion
67 
68         public void PreProceed(IInvocation invocation)
69         {
70             Console.WriteLine("PreProceed 2 代理了：{0}", invocation.Method.ToString());
71         }
72 
73         public void PostProceed(IInvocation invocation)
74         {
75             Console.WriteLine("PostProceed 2 代理了：{0}", invocation.Method.ToString());
76         }
77     }
78 
79     class DemoClassInterceptorTest
80     {
81         public static void DoTest()
82         {
83             ProxyGenerator generator = new ProxyGenerator();
84             DemoClassInterceptor interceptor = new DemoClassInterceptor();
85             DemoClassInterceptor2 interceptor2 = new DemoClassInterceptor2();
86             DemoClass obj = generator.CreateClassProxy<DemoClass>(interceptor, interceptor2);
87             obj.Text = "test";
88             obj.Add(10, 20);
89         }
90     }