示例#1
0
        private async Task Next(AspectContext context, AspectDelegate next, ICacheService cacheService, string key)
        {
            var scheduler = context.ServiceProvider.GetService <QuartzService>();

            if (!scheduler.CacheContainer.ContainsKey(key))
            {
                scheduler.CacheContainer.TryAdd(key, async() =>
                {
                    await next(context);

                    var value = await context.GetReturnValue();

                    if (value != null)
                    {
                        cacheService.Set(key, value);
                    }
                });

                scheduler.JoinJobAsync(key, TimeSpan.FromSeconds(Seconds)).Wait();
            }

            await next(context);

            var value = await context.GetReturnValue();

            if (value != null)
            {
                cacheService.Set(key, value);
            }
        }
示例#2
0
        /// <summary>
        /// 直接调用方法,并把结果加入缓存
        /// </summary>
        /// <param name="context"></param>
        /// <param name="next"></param>
        /// <param name="key">缓存key</param>
        /// <param name="type">缓存值类型</param>
        /// <returns></returns>
        public async Task GetDirectValueWithSetCache(AspectContext context, AspectDelegate next, string key, Type type)
        {
            //执行方法
            await next(context);

            //获取缓存过期时间
            var limitTime = GetCacheNewTime(Type, Length);
            var value     = await context.GetReturnValue();

            //加入缓存
            CacheProvider.Set(key, value, type, limitTime);
        }
        public async override Task Invoke(AspectContext context, AspectDelegate next)
        {
            if (!IsOpen || Seconds <= 0)
            {
                await next(context);

                return;
            }

            try
            {
                var cacheService = context.ServiceProvider.GetService <ICacheService>();

                Type returnType = context.GetReturnType();

                string key = Utils.GetParamterKey(Prefix, Key, ParamterKey, context.Parameters);

                var result = cacheService.Get(key, returnType);

                if (result == null)
                {
                    await next(context);

                    var value = await context.GetReturnValue();

                    if (value != null)
                    {
                        cacheService.Set(key, TimeSpan.FromSeconds(Seconds), value);
                    }
                }
                else
                {
                    context.ReturnValue = context.ResultFactory(result, returnType, context.IsAsync());
                }
            }
            catch (Exception ex)
            {
                var logger = context.ServiceProvider.GetService <ILogger <CacheMethodAttribute> >();

                logger.LogError($"CacheMethod:Key:{Key},ParamterKey:{ParamterKey} {ex.FormatMessage()}");

                await next(context);
            }
        }
        public async override Task Invoke(AspectContext context, AspectDelegate next)
        {
            if (!IsOpen)
            {
                await next(context);

                return;
            }

            try
            {
                var redis  = context.ServiceProvider.GetService <IRedisService>();
                var option = context.ServiceProvider.GetService <IOptions <CacheOptions> >();

                Type returnType = context.GetReturnType();

                string key = Utils.GetParamterKey("", "", Key, context.Parameters);

                var result = redis.HashGet <string>(HashKey, key, option.Value.RedisRead, RedisSerializerOptions.RedisValue);

                if (result.IsEmpty())
                {
                    await next(context);

                    var value = await context.GetReturnValue();

                    if (value != null)
                    {
                        var json = JsonConvert.SerializeObject(value);

                        if (Seconds > 0)
                        {
                            bool exists = redis.KeyExists(HashKey, option.Value.RedisRead);

                            redis.HashSet(HashKey, key, json, option.Value.RedisWrite, RedisSerializerOptions.RedisValue);

                            if (!exists)
                            {
                                redis.KeyExpire(HashKey, Seconds, option.Value.RedisWrite);
                            }
                        }
                        else
                        {
                            redis.HashSet(HashKey, key, json, option.Value.RedisWrite, RedisSerializerOptions.RedisValue);
                        }
                    }
                }
                else
                {
                    var value = JsonConvert.DeserializeObject(result, returnType);

                    context.ReturnValue = context.ResultFactory(value, returnType, context.IsAsync());
                }
            }
            catch (Exception ex)
            {
                var logger = context.ServiceProvider.GetService <ILogger <RedisCacheMethodAttribute> >();

                logger.LogError($"RedisCacheMethod:Key:{Key} {ex.FormatMessage()}");

                await next(context);
            }
        }