public async Task <string> GetAsync(int type = 1)
        {
            if (type == 1)
            {
                await _provider.RemoveAsync("demo");

                return("removed");
            }
            else if (type == 2)
            {
                await _provider.SetAsync("demo", "123", TimeSpan.FromMinutes(1));

                return("seted");
            }
            else if (type == 3)
            {
                var res = await _provider.GetAsync("demo", async() => await Task.FromResult("456"), TimeSpan.FromMinutes(1));

                return($"cached value : {res}");
            }
            else
            {
                return("error");
            }
        }
        public async Task <string> GetAsync(string str)
        {
            var method = str.ToLower();

            switch (method)
            {
            case "get":
                var res = await _provider.GetAsync("demo", async() => await Task.FromResult("3-456"), TimeSpan.FromHours(1));

                return($"cached value : {res}");

            case "set":
                await _provider.SetAsync("demo", "3-123", TimeSpan.FromHours(1));

                return("seted");

            case "remove":
                await _provider.RemoveAsync("demo");

                return("removed");

            default:
                return("default");
            }
        }
        public Task RemoveAsync(string key, CancellationToken token = default)
        {
            if (key == null)
            {
                throw new ArgumentNullException(nameof(key));
            }

            _expirations.TryRemove(key, out TimeSpan _);

            return(_hybridCachingProvider.RemoveAsync(key));
        }
示例#4
0
        public async Task SetAsync_And_RemoveAsync_Should_Succeed()
        {
            var cacheKey = $"{_namespace}_{Guid.NewGuid().ToString()}";

            await hybridCaching_1.SetAsync(cacheKey, "val", TimeSpan.FromSeconds(30));

            await hybridCaching_1.RemoveAsync(cacheKey);

            var res = await hybridCaching_1.ExistsAsync(cacheKey);

            Assert.False(res);
        }
        /// <summary>
        /// 移除token
        /// </summary>
        /// <param name="context"></param>
        /// <returns></returns>
        private async Task RemoveToken(HttpContext context)
        {
            var tokenTxt = await context.GetTokenAsync("access_token");

            var claimsInfo = GetClaimsInfo(tokenTxt);

            if (claimsInfo.Account.IsNotNullOrWhiteSpace())
            {
                var tokenKey = $"{tokenPrefx}:{claimsInfo.Account}:{claimsInfo.Id}";
                //var refreshTokenKey = $"{refreshTokenPrefx}:{claimsInfo.Account}:{claimsInfo.Id}";
                //await _cache.RemoveAllAsync(new List<string>() { key, refreshTokenKey });
                await _cache.RemoveAsync(tokenKey);
            }
        }