为了帮助大家更深刻地认识Dora.Interception，并更好地将它应用到你的项目中，我们通过如下几个简单的实例来演示几个常见的AOP应用在Dora.Interception下的实现。对于下面演示的实例，它们仅仅是具有指导性质的应用，所以我会尽可能地简化，如果大家需要将相应的应用场景移植到具体的项目开发中，需要做更多的优化。源代码从这里下载。

目录
一、对输入参数的格式化
二、对参数的自动化验证
三、对方法的返回值进行自动缓存

一、对输入参数的格式化

我们有一些方法对输入参数在格式上由一些要求，但是我们有不希望对原始传入的参数做过多的限制，那么我们可以通过AOP的方式对输入参数进行格式化。以如下这段代码为例，Demo的Invoke方法有一个字符串类型的参数input，我们希望该值总是以大写的形式存储下来，但是有希望原始的输入不区分大小写，于是我们按照如下的方式在参数上标注一个UpperCaseAttribute。这种类型的格式转换是通过我们自定义的一个名为ArgumentConversionInterceptor的Interceptor实现的，标准在方法上的ConvertArgumentsAttribute就是它对应的InterceptorAttribute。在Main方法中，我们按照DI的形式创建Demo对象（实际上是Demo代理对象），并调用其Invoke方法，那么以小写格式传入的参数将自动转换成大写形式。

  1 class Program  2 {  3     static void Main(string[] args)  4     {  5         var demo = new ServiceCollection()  6                 .AddSingleton<Demo, Demo>()  7                 .BuildInterceptableServiceProvider()  8                 .GetRequiredService<Demo>();  9         Debug.Assert(demo.Invoke("foobar") == "FOOBAR"); 10     } 11 } 12 public class Demo 13 { 14     [ConvertArguments] 15     public virtual string Invoke([UpperCase]string input) 16     { 17         return input; 18     } 19 }

接下来我们就利用Dora.Intercecption来实现这个应用场景。对应标注在参数input上的UpperCaseAttribute用于注册一个对应的ArgumentConvertor，因为它的本质工作是进行参数的转换，抽象的ArgumentConvertor通过如下这个接口来表示。IArgumentConvertor具有一个唯一的方式Convert来完成针对参数的转化，该方法的输入是一个ArgumentConveresionContext对象，通过这个上下文对象我们可以获取代表当前参数的ParameterInfo对象和参数值。

  1 public interface IArgumentConvertor  2 {  3     object Convert(ArgumentConveresionContext context);  4 }  5   6 public class ArgumentConveresionContext  7 {  8     public ParameterInfo ParameterInfo { get; }  9     public object Value { get; } 10  11     public ArgumentConveresionContext(ParameterInfo parameterInfo, object valule) 12     { 13         this.ParameterInfo = parameterInfo; 14         this.Value = valule; 15     } 16 }

就像Dora.Interception将Interceptor和Interceptor的提供刻意分开一样，我们同样将提供ArgumentConvertor的ArgumentConvertorProvider通过如下这个接口来表示。

  1 public interface IArgumentConvertorProvider  2 {  3     IArgumentConvertor GetArgumentConvertor();  4 }

简单起见，我们让UpperCaseAttribute同时实现IArgumentConvertor和IArgumentConvertorProvider接口。在实现的Convert方法中，我们将输入的参数转换成大写形式，至于实现的另一个方法GetArgumentConvertor，只需要返回它自己就可以了。

  1 [AttributeUsage(AttributeTargets.Parameter)]  2 public class UpperCaseAttribute : Attribute, IArgumentConvertor, IArgumentConvertorProvider  3 {  4     public object Convert(ArgumentConveresionContext context)  5     {  6         if (context.ParameterInfo.ParameterType == typeof(string))  7         {  8             return context.Value?.ToString()?.ToUpper();  9         } 10         return context.Value; 11     } 12  13     public IArgumentConvertor GetArgumentConvertor() 14     { 15         return this; 16     } 17 }

我们最后来看看真正完成参数转换的Interceptor是如何实现的。如下面的代码所示，在ArgumentConversionInterceptor的InvokeAsync方法中，我们通过标识方法调用上下文的InvocationContext对象的TargetMethod属性得到表示目标方法的MethodInfo对象，然后解析出标准在参数上的所有ArgumentConverterProvider。然后通过InvocationContext的Arguments属性得到对应的参数值，并将参数值和对应的MethodInfo对象创建出ArgumentConveresionContext对象，后者最后传入由ArgumentConverterProvider提供的ArgumentConvertor作相应的参数。被转换后的参数被重新写入由InvocationContext的Arguments属性表示的参数列表中即可。

  1 public class ArgumentConversionInterceptor  2 {  3     private InterceptDelegate _next;  4   5     public ArgumentConversionInterceptor(InterceptDelegate next)  6     {  7         _next = next;  8     }  9  10     public Task InvokeAsync(InvocationContext invocationContext) 11     { 12         var parameters = invocationContext.TargetMethod.GetParameters(); 13         for (int index = 0; index < invocationContext.Arguments.Length; index++) 14         { 15             var parameter = parameters[index]; 16             var converterProviders = parameter.GetCustomAttributes(false).OfType<IArgumentConvertorProvider>().ToArray(); 17             if (converterProviders.Length > 0) 18             { 19                 var convertors = converterProviders.Select(it => it.GetArgumentConvertor()).ToArray(); 20                 var value = invocationContext.Arguments[0]; 21                 foreach (var convertor in convertors) 22                 { 23                     var context = new ArgumentConveresionContext(parameter, value); 24                     value = convertor.Convert(context); 25                 } 26                 invocationContext.Arguments[index] = value; 27             } 28         } 29         return _next(invocationContext); 30     } 31 } 32  33 public class ConvertArgumentsAttribute : InterceptorAttribute 34 { 35     public override void Use(IInterceptorChainBuilder builder) 36     { 37         builder.Use<ArgumentConversionInterceptor>(this.Order); 38     } 39 }

二、对参数的自动化验证

将相应的验证规则应用到方法的参数上，进而实现自动化参数验证是AOP的一个更加常见的应用场景。一如下的代码片段为例，还是Demo的Invoke方法，我们在input参数上应用一个MaxLengthAttribute特性，这是微软自身提供的一个用于限制字符串长度的ValidationAttribute。在这个例子中，我们将字符串长度限制为5个字符以下，并提供了一个验证错误消息。针对对参数实施验证的是标准在方法上的ValidateArgumentsAttribute提供的Interceptor。在Main方法中，我们按照DI的方式得到Demo对应的代理对象，并调用其Invoke方法。由于传入的字符串（“Foobar”）的长度为6，所以验证会失败，后果就是会抛出一个ValidationException类型的异常，后者被进一步封装成AggregateException异常。

  1 class Program  2 {  3     static void Main(string[] args)  4     {  5         var demo = new ServiceCollection()  6                 .AddSingleton<Demo, Demo>()  7                 .BuildInterceptableServiceProvider()  8                 .GetRequiredService<Demo>();  9             try 10             { 11                 demo.Invoke("Foobar"); 12                 Debug.Fail("期望的验证异常没有抛出"); 13             } 14             catch (AggregateException ex) 15             { 16                 ValidationException validationException = (ValidationException)ex.InnerException; 17                 Debug.Assert("字符串长度不能超过5" == validationException.Message); 18             } 19     } 20 } 21 public class Demo 22 { 23     [ValidateArguments] 24     public virtual string Invoke( 25         [MaxLength(5, ErrorMessage ="字符串长度不能超过5")] 26         string input) 27     { 28         return input; 29     } 30 }

那么我们看看ValidateArgumentsAttribute和由它提供的Interceptor具有怎样的实现。从下面给出的代码可以看出ValidationInterceptor的实现与上面这个ArgumentConversionInterceptor具有类似的实现，逻辑非常简单，我就不作解释的。在这里我顺便说说另一个问题：有一些框架会将Interceptor直接应用到参数上（比如WCF可以定义ParameterInspector来对参数进行检验），我觉得从设计上讲是不妥的，因为AOP的本质是针对方法的拦截，所以Interceptor最终都只应该与方法进行映射，针对参数验证、转化以及其他基于参数的处理都应该是具体某个Interceptor自身的行为。换句话说，应用在参数上的规则是为具体某种类型的Interceptor服务的，这些规则应该由对应的Interceptor来解析，但是Interceptor自身不应该映射到参数上。

  1 public class ValidationInterceptor  2 {  3     private InterceptDelegate _next;  4   5     public ValidationInterceptor(InterceptDelegate next)  6     {  7         _next = next;  8     }  9  10     public Task InvokeAsync(InvocationContext invocationContext) 11     { 12         var parameters = invocationContext.TargetMethod.GetParameters(); 13         for (int index = 0; index < invocationContext.Arguments.Length; index++) 14         { 15             var parameter = parameters[index]; 16             var attributes = parameter.GetCustomAttributes(false).OfType<ValidationAttribute>(); 17             foreach (var attribute in attributes) 18             { 19                 var value = invocationContext.Arguments[index]; 20                 var context = new ValidationContext(value); 21                 attribute.Validate(value, context); 22             } 23         } 24         return _next(invocationContext); 25     } 26 } 27  28 public class ValidateArgumentsAttribute : InterceptorAttribute 29 { 30     public override void Use(IInterceptorChainBuilder builder) 31     { 32         builder.Use<ValidationInterceptor>(this.Order); 33     } 34 }

三、对方法的返回值进行自动缓存

有时候我们会定义这样一些方法：方法自身会进行一些相对耗时的操作并返回最终的处理结果，并且方法的输入决定方法的输出。对于这些方法，为了避免耗时方法的频繁执行，我们可以采用AOP的方式对方法的返回值进行自动缓存，我们照例先来看看最终的效果。如下面的代码片段所示，Demo类型具有一个GetCurrentTime返回当前时间，它具有一个参数用来指定返回时间的Kind（Local、UTC或者Unspecified）。该方法上标注了一个CaheReturnValueAttribute提供一个Interceptor来缓存方法的返回值。缓存是针对输入参数进行的，也就是说，如果输入参数一致，得到的执行结果就是相同的，Main方法的调试断言证实了这一点。

class Program{    static void Main(string[] args)    {        var demo = new ServiceCollection()                .AddMemoryCache()                .AddSingleton<Demo, Demo>()                .BuildInterceptableServiceProvider()                .GetRequiredService<Demo>();        var time1 = demo.GetCurrentTime(DateTimeKind.Local);        Thread.Sleep(1000);        Debug.Assert(time1 == demo.GetCurrentTime(DateTimeKind.Local));        var time2 = demo.GetCurrentTime(DateTimeKind.Utc);        Debug.Assert(time1 != time2);        Thread.Sleep(1000);        Debug.Assert(time2 == demo.GetCurrentTime(DateTimeKind.Utc));        var time3 = demo.GetCurrentTime(DateTimeKind.Unspecified);        Debug.Assert(time3 != time1);        Debug.Assert(time3 != time2);        Thread.Sleep(1000);        Debug.Assert(time3 == demo.GetCurrentTime(DateTimeKind.Unspecified));        Console.Read();    }} public class Demo{    [CacheReturnValue]    public virtual DateTime GetCurrentTime(DateTimeKind dateTimeKind)    {        switch (dateTimeKind)        {            case DateTimeKind.Local: return DateTime.Now.ToLocalTime();            case DateTimeKind.Utc: return DateTime.UtcNow;            default: return DateTime.Now;        }    }}

现在我们实现缓存的CacheInterceptor是如何定义的，不过在这之前我们先来看看作为缓存的Key的定义。缓存的Key是具有如下定义的CacheKey，它由两部分组成，表示方法的MethodBase和调用方法传入的参数。

public struct Cachekey{public MethodBase Method { get; }public object[] InputArguments { get; }public Cachekey(MethodBase method, object[] arguments){    this.Method = method;    this.InputArguments = arguments;}public override bool Equals(object obj){    if (!(obj is Cachekey))    {        return false;    }    Cachekey another = (Cachekey)obj;       if (!this.Method.Equals(another.Method))    {        return false;    }    for (int index = 0; index < this.InputArguments.Length; index++)    {        var argument1 = this.InputArguments[index];        var argument2 = another.InputArguments[index];        if (argument1 == null && argument2 == null)        {            continue;        }        if (argument1 == null || argument2 == null)        {            return false;        }        if (!argument2.Equals(argument2))        {            return false;        }    }    return true;}public override int GetHashCode(){    int hashCode = this.Method.GetHashCode();    foreach (var argument in this.InputArguments)    {        hashCode = hashCode ^ argument.GetHashCode();    }    return hashCode;}}

如下所示的是CacheInterceptor的定义，可以看出实现的逻辑非常简单。CacheInterceptor采用以方法注入形式提供的IMemoryCache 来对方法调用的返回值进行缓存。在InvokeAsync方法中，我们根据当前执行上下文提供的代表当前方法的MethodBase和输入参数创建作为缓存Key的CacheKey对象。如果根据这个Key能够从缓存中提取相应的返回值，那么它会直接将此值保存到执行上下文中，并且终止当前方法的调用。反之，如果返回值尚未被缓存，它会继续后续的调用，并在调用结束之后将返回值存入缓存，以便后续调用时使用。

public class CacheInterceptor{    private readonly InterceptDelegate _next;                public CacheInterceptor(InterceptDelegate next)    {        _next = next;                        }    public async Task InvokeAsync(InvocationContext context, IMemoryCache cache)    {        var key = new Cachekey(context.Method, context.Arguments);        if (cache.TryGetValue(key, out object value))        {            context.ReturnValue = value;        }        else        {            await _next(context);            cache.Set(key, context.ReturnValue);        }    } }

我们标注在GetCurrent方法上的CacheReturnValueAttribute定义如下，它只需要在重写的Use方法中按照标准的方式注册上面这个CacheInterceptor即可。顺便再说一下，将Interceptor和注册它的Attribute进行分离还具有一个好处：我可以为Attribute指定一个不同的名称，比如这个CacheReturnValueAttribute。

[AttributeUsage(AttributeTargets.Method)]public class CacheReturnValueAttribute : InterceptorAttribute{    public override void Use(IInterceptorChainBuilder builder)    {        builder.Use<CacheInterceptor>(this.Order);    }}

Dora.Interception, 为.NET Core度身打造的AOP框架 [1]：全新的版本
Dora.Interception, 为.NET Core度身打造的AOP框架 [2]：不一样的Interceptor定义方式
Dora.Interception, 为.NET Core度身打造的AOP框架 [3]：Interceptor的注册
Dora.Interception, 为.NET Core度身打造的AOP框架 [4]：演示几个典型应用