为了帮助大家更深刻地认识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]：演示几个典型应用

原文地址：https://www.cnblogs.com/artech/p/dora2-04.html