没有人喜欢样板代码. 我们通常通过使用常见的面向对象编程模式来减少它, 但是，通常使用模式的代码开销与我们最初使用样板代码时几乎相同，如果不是更大的话. 以某种方式标记应该实现某些行为的部分代码将是非常好的, and resolve implementation somewhere else.

例如，如果我们有 StudentRepository, we can use Dapper to get all the students from a relational database:

公共类StudentRepository
{
    public Task> GetAllAsync(IDbConnection connection)
    {
        return connection.GetAllAsync();
    }
}

这是关系数据库存储库的一个非常简单的实现. 如果学生名单变化不大并且经常被调用, 我们可以缓存这些项来优化系统的响应时间. 因为我们的代码中通常有很多存储库(不管它们是否关系), 把缓存的横切问题放在一边，并很容易地利用它，这是很好的, like:

公共类StudentRepository
{
    [Cache]
    public Task> GetAllAsync(IDbConnection connection)
    {
        return connection.GetAllAsync();
    }
}

A bonus would be not to worry about database connections. Have this cross-cutting concern aside as well, and just label a method to use external connection manager, like:

公共类StudentRepository
{
    [Cache]
    [DbConnection]
    public Task> GetAllAsync(IDbConnection = null
    {
        return connection.GetAllAsync();
    }
}

在本文中，我们将考虑使用面向方面的模式，而不是常用的OOP. 尽管AOP已经存在了一段时间，但开发人员通常更喜欢OOP而不是AOP. 虽然你用AOP做的所有事情都可以用OOP来做，比如过程编程和面向对象编程. 面向对象、AOP为开发人员提供了更多可以使用的范例选择. AOP代码的组织方式不同, 有些人可能会辩称得更好, on certain aspects (pun intended) than OOP. 最后，选择使用哪种范式是个人偏好.

How We Do It

In .. NET中，AOP模式可以使用中间语言编织实现，更广为人知的是 IL weaving. 这是一个在代码编译后启动的过程, and it changes the IL code produced by a compiler, to make the code achieve expected behavior. So, looking at the example already mentioned, 尽管我们没有在这门课中编写缓存代码, 为了调用缓存代码，我们编写的方法将被更改(或替换). 为了便于说明，最终结果应该是这样的:

//由PostSharp编织

公共类StudentRepository
{
    [DebuggerTargetMethod (100663306)]
    [DebuggerBindingMethod (100663329)]
    [DebuggerBindingMethod (100663335)]
    public async Task> GetAllAsync(
      IDbConnection = null
    {
      AsyncMethodInterceptionArgsImpl> interceptionArgsImpl;
      try
      {
        // ISSUE: reference to a compiler-generated field
        await <>z__a_1.a2.OnInvokeAsync ((MethodInterceptionArgs) interceptionArgsImpl);
        // ISSUE: reference to a compiler-generated field
        this.<>1__state = -2;
      }
      finally
      {
      }
      return (IEnumerable) interceptionArgsImpl.TypedReturnValue;
    }

    [DebuggerSourceMethod (100663300)]
    private Task> z__OriginalMethod(
      [可选]IDbConnection连接
    {
      return (Task>) SqlMapperExtensions.GetAllAsync(connection, (IDbTransaction) null, new int?());
    }
}

Tools Required

本文中的所有代码，包括方面和集成测试，都可以在 notmarkopadjen/dot-net-aspects-postsharp GitHub repository. 对于IL编织，我们将使用 PostSharp 从Visual Studio市场. 这是一个商业工具，商业用途需要获得许可. 为了进行实验，您可以选择PostSharp Essentials许可证，它是免费的.

如果你想运行集成测试，你将需要MySQL和Redis服务器. 在上面的代码中，我使用MariaDB 10做了一个Docker Compose实验.4 and Redis 5.0. In order to use it, you will need to install Docker 组合配置:

docker-compose up -d

当然，您可以使用其他服务器并更改中的连接字符串 appsettings.json.

基本面向方面的编码

Let’s try out AOP’s interception pattern. 要在PostSharp中做到这一点，我们需要实现一个新属性，继承 MethodInterceptionAspect attribute and override required methods.

[PSerializable]
[AttributeUsage AttributeTargets.类| AttributeTargets.Method)]
public class CacheAttribute : MethodInterceptionAspect
{
    // ...

    OnInvoke(MethodInterceptionArgs)
    {
        // ...
var redisValue = db.StringGet(key);
        // ...
    }
    
    OnInvokeAsync(MethodInterceptionArgs)
    {
        // ...
var redisValue =等待db.StringGetAsync(key);
        // ...
    }
}

我们看到，我们有两种不同的同步和异步调用方法. 重要的是要正确地实施这些措施，以充分利用它们 .NET async features. 从Redis读取时使用 StackExchange.Redis library, we use StringGet or StringGetAsync 方法调用，这取决于我们是在同步还是异步代码分支中.

Code execution flow is affected by invoking methods of MethodInterceptionArgs, args 对象，并为该对象的属性设置值. 最重要的成员:

• Proceed (ProceedAsync) method - Invokes original method execution.
• ReturnValue property - Contains the return value of the method call. 在原始方法执行之前，它是空的，在它包含原始返回值之后. 可随时更换.
• Method property - System.Reflection.MethodBase (usually System.Reflection.MethodInfo) contains target method reflection information.
• Instance property - Target object (method parent instance).
• Arguments 属性-包含参数值. 可随时更换.

DbConnection方面

我们希望能够在没有实例的情况下调用存储库方法 IDbConnection，让方面创建这些连接，并将其提供给方法调用. 有时，您可能希望无论如何都提供连接(例如.g.(因为事务)，在这种情况下，方面不应该做任何事情.

在下面的实现中, we will have code only for database connection management, as we would have in any database entity repository. In this particular case, an instance of MySqlConnection 解析为方法执行并在方法执行完成后处理.

using Microsoft.Extensions.Configuration;
using MySql.Data.MySqlClient;
using PostSharp.Aspects;
using PostSharp.Aspects.Dependencies;
using PostSharp.Serialization;
using System;
using System.Data;
using System.Threading.Tasks;

namespace Paden.Aspects.Storage.MySQL
{
    [PSerializable]
    [ProvideAspectRole StandardRoles.TransactionHandling)]
    [AspectRoleDependency(AspectDependencyAction.秩序,AspectDependencyPosition.After, StandardRoles.Caching)]
    [AttributeUsage AttributeTargets.类| AttributeTargets.Method)]
    DbConnectionAttribute: MethodInterceptionAspect
    {
        const string DefaultConnectionStringName = "DefaultConnection";

        static Lazy config;

        连接字符串;
        公共静态字符串ConnectionString
        {
            返回连接字符串 ?? config.Value.GetConnectionString(DefaultConnectionStringName); }
            set { connectionString = value; }
        }

        静态DbConnectionAttribute ()
        {
            config = new Lazy(() => new ConfigurationBuilder().AddJsonFile(“appsettings.json", false, false).Build());
        }

        OnInvoke(MethodInterceptionArgs)
        {
            var i = GetArgumentIndex(args);
            if (!i.HasValue)
            {
                args.Proceed();
                return;
            }

            使用(IDbConnection db = new MySqlConnection(ConnectionString))
            {
                args.Arguments.SetArgument(i.Value, db);
                args.Proceed();
            }
        }

        OnInvokeAsync(MethodInterceptionArgs)
        {
            var i = GetArgumentIndex(args);
            if (!i.HasValue)
            {
                await args.ProceedAsync();
                return;
            }

            使用(IDbConnection db = new MySqlConnection(ConnectionString))
            {
                args.Arguments.SetArgument(i.Value, db);
                await args.ProceedAsync();
            }
        }

        private int? GetArgumentIndex(MethodInterceptionArgs args)
        {
            var parameters = args.Method.GetParameters();
            for (int i = 0; i < parameters.Length; i++)
            {
                Var参数=参数[i];
                if (parameter.ParameterType == typeof(IDbConnection)
                    && parameter.IsOptional
                    && args.Arguments[i] == null)
                {
                    return i;
                }
            }
            return null;
        }
    }
}

在这里，重要的是指定方面的执行顺序. 在这里，它是通过分配方面角色和排序角色执行来完成的. We don’t want IDbConnection to be created if it’s not going to be used anyway (e.g.(从缓存中读取的值). It is defined by the following attributes:

[ProvideAspectRole StandardRoles.TransactionHandling)]
[AspectRoleDependency(AspectDependencyAction.秩序,AspectDependencyPosition.After, StandardRoles.Caching)]

PostSharp can also implement all aspects on class level, and assembly level, so it’s important to define attribute scope:

[AttributeUsage AttributeTargets.类| AttributeTargets.Method)]

The connection string is being read from appsettings.json, but can be overridden using static property ConnectionString.

执行流程如下:

1. Aspect identifies IDbConnection optional argument index which has no value provided. 如果没有找到，我们跳过.
2. MySqlConnection is created based on provided ConnectionString.
3. IDbConnection argument value is set.
4. 调用原始方法.

So, 如果我们想用这个方面, 我们可以在不提供连接的情况下调用repository方法:

等待studentRepository.InsertAsync(新学生
{
    名字=“不是马尔科·帕德扬”
}, connection: null);

Cache Aspect

这里我们想要识别唯一的方法调用并缓存它们. 如果使用相同的参数调用同一类的相同方法，则认为方法调用是唯一的.

在下面的实现中，在每个方法上，都为调用创建了拦截键. 然后用它来检查返回值是否存在于缓存服务器上. 如果是，则返回它而不调用原始方法. If it’s not, 调用原始方法, 返回的值保存到缓存服务器以供进一步使用.

using Microsoft.Extensions.Configuration;
using Newtonsoft.Json;
using PostSharp.Aspects;
using PostSharp.Aspects.Dependencies;
using PostSharp.Serialization;
using StackExchange.Redis;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;

namespace Paden.Aspects.Caching.Redis
{
    [PSerializable]
    [ProvideAspectRole StandardRoles.Caching)]
    [AspectRoleDependency(AspectDependencyAction.秩序,AspectDependencyPosition.之前,StandardRoles.TransactionHandling)]
    [AttributeUsage AttributeTargets.类| AttributeTargets.Method)]
    public class CacheAttribute : MethodInterceptionAspect
    {
        const int DefaultExpirySeconds = 5 * 60;

        static Lazy redisServer;

        public int ExpirySeconds = DefaultExpirySeconds;
        private TimeSpan? Expiry => ExpirySeconds == -1 ? (TimeSpan?)null : TimeSpan.FromSeconds (ExpirySeconds);

        静态CacheAttribute ()
        {
            redisServer = new Lazy(() => new ConfigurationBuilder().AddJsonFile(“appsettings.json", false, false).Build()(“复述:服务器”));
        }        

        OnInvoke(MethodInterceptionArgs)
        {
            if (args.实例为ICacheAware cacheAware && !cacheAware.CacheEnabled)
            {
                args.Proceed();
                return;
            }

            var key = GetKey(args.方法作为MethodInfo，参数.Arguments);

            using (var connection = ConnectionMultiplexer.Connect(redisServer.Value))
            {
                var db = connection.GetDatabase();
                var redisValue = db.StringGet(key);

                if (redisValue.IsNullOrEmpty)
                {
                    args.Proceed();
                    db.StringSet(关键,JsonConvert.SerializeObject(args.ReturnValue),到期);
                }
                else
                {
                    args.ReturnValue = JsonConvert.DeserializeObject (redisValue.ToString(), (args.Method as MethodInfo).ReturnType);
                }
            }
        }

        OnInvokeAsync(MethodInterceptionArgs)
        {
            if (args.实例为ICacheAware cacheAware && !cacheAware.CacheEnabled)
            {
                await args.ProceedAsync();
                return;
            }

            var key = GetKey(args.方法作为MethodInfo，参数.Arguments);

            using (var connection = ConnectionMultiplexer.Connect(redisServer.Value))
            {
                var db = connection.GetDatabase();
                var redisValue =等待db.StringGetAsync(key);

                if (redisValue.IsNullOrEmpty)
                {
                    await args.ProceedAsync();
                    db.StringSet(关键,JsonConvert.SerializeObject(args.ReturnValue),到期);
                }
                else
                {
                    args.ReturnValue = JsonConvert.DeserializeObject (redisValue.ToString(), (args.Method as MethodInfo).ReturnType.GenericTypeArguments [0]);
                }
            }
        }

        private string GetKey(MethodInfo method, IList