.NET + AOP + AutoFac + Redis

直接上代码

using Autofac;
using Autofac.Extras.DynamicProxy;
using Framework.Core.AOP;
using Framework.Core.AOP.Cache;
using Framework.Core.Configuration;
using Framework.Core.DependencyInjection;
using Framework.Core.Extensions.DataType;
using Microsoft.Extensions.DependencyModel;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.Loader;
using System.Text;
using System.Threading.Tasks;

namespace Framework.Core.AutoFac
{
    public class AutofacModuleRegister : Autofac.Module
    {
        protected override void Load(ContainerBuilder builder)
        {
            var assemblyList = new List<Assembly>();
            var deps = DependencyContext.Default;
            var libs = deps.CompileLibraries.Where(lib => !lib.Serviceable && !lib.Type.Equals("package") && !lib.Name.Contains("Microsoft") && !lib.Name.Contains("System"));
            foreach (var lib in libs)
            {
                var assembly = AssemblyLoadContext.Default.LoadFromAssemblyName(new AssemblyName(lib.Name));
                assemblyList.Add(assembly);
            }

            if (!assemblyList.Any())
            {
                throw new Exception("未找到任何可以注入的接口，请查看项目是否依赖");
            }

            Assembly[] arrayAssembly = assemblyList.ToArray();

            // AOP 开关，如果想要打开指定的功能，只需要在 appsettigns.json 对应对应 true 就行。
            var cacheType = new List<Type>();
            if (AopConfig.IsOpenCacheRedisAop)
            {
                builder.RegisterType<RedisCacheAOP>();
                cacheType.Add(typeof(RedisCacheAOP));
            }
            else
            {
                builder.RegisterType<MemoryCacheAOP>();
                cacheType.Add(typeof(MemoryCacheAOP));
            }

            #region 继承接口注入

            //注入瞬时模式
            //每次请求获取的实例不同
            builder.RegisterAssemblyTypes(arrayAssembly)
                .Where(p => typeof(ITransientDependency).IsAssignableFrom(p) && p.IsClass)
                .AsImplementedInterfaces()
                .InstancePerDependency()
                .PropertiesAutowired()
                .EnableInterfaceInterceptors();
            //  .InterceptedBy(cacheType.ToArray());//允许将拦截器服务的列表分配给注册。 若去掉该注释，可以不添加[Intercept(typeof(RedisCacheAOP))]，所有依赖的类都会经过拦截器。


            //注入作用域模式
            //相同的作用域下获取的实例相同
            builder.RegisterAssemblyTypes(arrayAssembly)
                .Where(p => typeof(IScopedDependency).IsAssignableFrom(p) && p.IsClass)
                .AsImplementedInterfaces()
                .InstancePerLifetimeScope()
                .PropertiesAutowired();
                


            //单例模式
            //每次请求进来获取的实例都相同
            builder.RegisterAssemblyTypes(arrayAssembly)
               .Where(p => typeof(ISingletonDependency).IsAssignableFrom(p) && p.IsClass)
               .AsImplementedInterfaces()
               .SingleInstance()
               .PropertiesAutowired();

            #endregion


            //// 获取 Service.dll 程序集服务，并注册
            //var assemblysServices = Assembly.LoadFrom(servicesDllFile);
            //builder.RegisterAssemblyTypes(assemblysServices).AsImplementedInterfaces().InstancePerDependency()
            //    .PropertiesAutowired();
            //    //.EnableInterfaceInterceptors()//引用Autofac.Extras.DynamicProxy;
            //    //.InterceptedBy(cacheType.ToArray());//允许将拦截器服务的列表分配给注册。

            //// 获取 Repository.dll 程序集服务，并注册
            //var assemblysRepository = Assembly.LoadFrom(repositoryDllFile);
            //builder.RegisterAssemblyTypes(assemblysRepository).AsImplementedInterfaces().InstancePerDependency()
            //    .PropertiesAutowired();
        }
    }
}

using Castle.DynamicProxy;
using Framework.Core.AOP.Cache.Attribute;
using Framework.Core.Cache;
using Framework.Core.Extensions;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Framework.Core.AOP.Cache
{
    /// <summary>
    /// Redis AOP 拦截器
    /// </summary>
    public class RedisCacheAOP : IInterceptor
    {
        private readonly IRedisProvider _cache;

        public RedisCacheAOP(IRedisProvider redisProvider)
        {
            _cache = redisProvider;
        }
        public void Intercept(IInvocation invocation)
        {
            var method = invocation.MethodInvocationTarget ?? invocation.Method;
            //对当前方法的特性验证
            dynamic cachingAttr = method.GetCustomAttributes(true).FirstOrDefault(x => x.GetType() == typeof(CachingAttribute));
            if (cachingAttr != null)
            {
                //获取自定义缓存键
                var cacheKey = CustomCacheKey(invocation);
                //注意是 string 类型，方法GetValue
                var cacheValue = _cache.GetValue(cacheKey).Result;
                if (cacheValue != null)
                {
                    //将当前获取到的缓存值，赋值给当前执行方法
                    var type = invocation.Method.ReturnType;
                    var resultTypes = type.GenericTypeArguments;
                    if (type.FullName == "System.Void")
                    {
                        return;
                    }
                    object response;
                    if (typeof(Task).IsAssignableFrom(type))
                    {
                        //返回Task<T>
                        if (resultTypes.Any())
                        {
                            dynamic temp = cacheValue.FromJson(resultTypes.First());
                            response = Task.FromResult(temp);
                        }
                        else
                        {
                            //Task 无返回方法 指定时间内不允许重新运行
                            response = Task.Yield();
                        }
                    }
                    else
                    {
                        // 核心2，要进行 ChangeType
                        response = Convert.ChangeType(_cache.Get<object>(cacheKey), type);
                    }
                    invocation.ReturnValue = response;
                    return;
                }
                //去执行当前的方法
                invocation.Proceed();

                //存入缓存
                if (!string.IsNullOrWhiteSpace(cacheKey))
                {
                    object response;

                    //Type type = invocation.ReturnValue?.GetType();
                    var type = invocation.Method.ReturnType;
                    if (typeof(Task).IsAssignableFrom(type))
                    {
                        var resultProperty = type.GetProperty("Result");
                        response = resultProperty.GetValue(invocation.ReturnValue);
                    }
                    else
                    {
                        response = invocation.ReturnValue;
                    }
                    if (response == null) response = string.Empty;
                    var exp = TimeSpan.FromMinutes(cachingAttr.AbsoluteExpiration);
                    _cache.Set(cacheKey, response, exp).Wait();
                }
            }
            else
            {
                invocation.Proceed();//直接执行被拦截方法
            }
        }

        //自定义缓存键
        private string CustomCacheKey(IInvocation invocation)
        {
            var typeName = invocation.TargetType.Name;
            var methodName = invocation.Method.Name;
            var methodArguments = invocation.Arguments.Select(GetArgumentValue).Take(3).ToList();//获取参数列表，最多三个

            string key = $"{typeName}:{methodName}:";
            foreach (var param in methodArguments)
            {
                key += $"{param}:";
            }

            return key.TrimEnd(':');
        }

        //object 转 string
        private string GetArgumentValue(object arg)
        {
            if (arg is int || arg is long || arg is string)
                return arg.ToString();

            if (arg is DateTime)
                return ((DateTime)arg).ToString("yyyyMMddHHmmss");

            return "";
        }
    }
}

使用方式在注入到容器的接口类里面添加特性就可以实现拦截，在方法上添加缓存时效的特性就能实现改放回结果缓存

缓存特性实现类

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Framework.Core.AOP.Cache.Attribute
{
    /// <summary>
    /// 这个Attribute就是使用时候的验证，把它添加到要缓存数据的方法中，即可完成缓存的操作。
    /// </summary>
    [AttributeUsage(AttributeTargets.Method, Inherited = true)]
    public class CachingAttribute : System.Attribute
    {
        /// <summary>
        /// 缓存绝对过期时间（分钟）
        /// </summary>
        public int AbsoluteExpiration { get; set; } = 30;
    }
}