.Net core中使用缓存 写入/读取数据

先看缓存的封装类，可以直接封装拿来使用

using Microsoft.Extensions.Caching.Distributed;
using System.Text.Json;

namespace WebApplication3.CommonHelper
{
    public class CacheService
    {
        private readonly IDistributedCache _cache;

        public CacheService(IDistributedCache cache)
        {
            _cache = cache;
        }

        /// <summary>
        /// 保存到缓存
        /// </summary>
        /// <param name="data">值</param>
        /// <param name="key">键</param>
        /// <param name="sliding">相对过期时间</param>
        /// <param name="expiration">绝对过期时间</param>
        /// <returns></returns>
        public async Task SetValueAsync(string key, object data, int sliding, int expiration)
        {
            byte[] bytes = JsonSerializer.SerializeToUtf8Bytes(data);
            await _cache.SetAsync(key, bytes, new DistributedCacheEntryOptions()
            {
                SlidingExpiration = TimeSpan.FromMinutes(sliding),
                AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(expiration)
            });
        }

        /// <summary>
        /// 获取缓存
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        public T? GetValue<T>(string key)
        {
            byte[]? bytes = _cache.Get(key);
            if (bytes == null || bytes.Length < 1)
            {
                return default;
            }
            ReadOnlySpan<byte> readOnlySpan = new(bytes);
            return JsonSerializer.Deserialize<T>(readOnlySpan);
        }
        public async Task<T> GetCacheAsync<T>(string key)
        {
            byte[] cacheData = await _cache.GetAsync(key);

            if (cacheData != null)
            {
                T cachedObject = JsonSerializer.Deserialize<T>(cacheData)!;
                return cachedObject;
            }
            else
            {
                return default!; // 如果没有找到缓存数据，返回默认值（null 或适当的默认值）
            }
        }
        /// <summary>
        /// 删除缓存
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public async Task RemoveCacheAsync(string key)
        {
            await _cache.RemoveAsync(key);
        }
        /// <summary>
        /// 检查缓存是否存在
        /// </summary>
        /// <param name="key">缓存键</param>
        /// <returns>返回布尔值表示是否存在</returns>
        public async Task<bool> IsCacheExistsAsync(string key)
        {
            var cacheValue = await _cache.GetAsync(key);

            // 如果缓存项为null，表示缓存中没有这个键
            return cacheValue != null;
        }
    }
}

   使用的话要在Program中注入一下

#region 注册内存缓存
services.AddDistributedMemoryCache();
services.TryAddSingleton(typeof(CacheService));
#endregion

使用示例

 public class AuthController : ControllerBase
    {
        private readonly IConfiguration _config;
        private readonly CacheService _rides;
        public AuthController(IConfiguration configuration, CacheService rides)
        {
            _config = configuration;
            _rides = rides;
        }
 /// <summary>
        /// 写入数据
        /// </summary>
        /// <param name="id"></param>
        /// <param name="name"></param>
        /// <returns></returns>
        [HttpPost("SetValue")]
        public async Task<IActionResult> SetValue(int id, string name)
        {
            await _rides.SetValueAsync($"_ccc{id}", new { name = name }, 10, 10);
            return Ok(1);
        }
        /// <summary>
        /// 读取数据
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpPost("GetValue")]
        public async Task<IActionResult> GetValue(int id)
        {
            var cc = await _rides.GetCacheAsync<object>($"_ccc{id}");
            return Ok(1);
        }
    }