【愚公系列】2023年03月 MES生产制造执行系统-003.Redis和内存缓存的使用

愚公搬代码

发布于 2023-03-16 19:07:00

4520

发布于 2023-03-16 19:07:00

文章被收录于专栏：历史专栏

文章目录

前言

内存缓存是一种将数据存储在内存中的技术，可以提高数据的读取速度和响应速度。常见的内存缓存技术包括 Redis、Memcached 等。在应用程序中，可以使用内存缓存来缓存一些常用的数据，以减少对数据库等存储介质的访问，从而提高应用程序的性能。

Redis是一个开源的、高效的、键值存储数据库。它支持多种数据结构，如字符串、哈希、列表、集合、有序集合等，可以作为数据库、缓存和消息代理等使用。它特别适合用于需要快速读写、排序、分析大量数据的场景。

CSRedisCore是一个基于C#的Redis客户端，用于与Redis数据库进行交互。它提供了简单易用的API，可以方便地进行数据读写、事务处理、发布订阅等操作。

CSRedisCore源码：https://github.com/2881099/csredis

一、Redis和内存缓存的使用

Autofac的最后一个注入功能就是根据配置文件切换缓存

//启用缓存
if (AppSetting.UseRedis)
{
    builder.RegisterType<RedisCacheService>().As<ICacheService>().SingleInstance();
}
else
{
    builder.RegisterType<MemoryCacheService>().As<ICacheService>().SingleInstance();
}

1.安装包

CSRedisCore

2.封装

2.1 ICacheService 接口

public interface ICacheService : IDisposable
{
    /// <summary>
    /// 验证缓存项是否存在
    /// </summary>
    /// <param name="key">缓存Key</param>
    /// <returns></returns>
    bool Exists(string key);



    /// <summary>
    /// List写入head
    /// </summary>
    /// <param name="key"></param>
    /// <param name="val"></param>
    void LPush(string key, string val);

    void RPush(string key, string val);
    /// <summary>
    /// List出队 lpop
    /// </summary>
    /// <param name="key"></param>
    /// <returns></returns>
    object ListDequeue(string key);

    /// <summary>
    /// List出队 lpop
    /// </summary>
    /// <param name="key"></param>
    /// <returns></returns>
    T ListDequeue<T>(string key) where T : class;

    /// <summary>
    /// 移除list中的数据，keepIndex为保留的位置到最后一个元素如list 元素为1.2.3.....100
    /// 需要移除前3个数，keepindex应该为4
    /// </summary>
    /// <param name="key"></param>
    /// <param name="keepIndex"></param>
    void ListRemove(string key, int keepIndex);

    /// <summary>
    /// 添加缓存
    /// </summary>
    /// <param name="key">缓存Key</param>
    /// <param name="value">缓存Value</param>
    /// <param name="expiresIn">缓存时长</param>
    /// <param name="isSliding">是否滑动过期（如果在过期时间内有操作，则以当前时间点延长过期时间） //new TimeSpan(0, 60, 0);</param>
    /// <returns></returns>
    bool AddObject(string key, object value, int expireSeconds = -1, bool isSliding = false);

    bool Add(string key, string value, int expireSeconds = -1, bool isSliding = false);

    /// <summary>
    /// 删除缓存
    /// </summary>
    /// <param name="key">缓存Key</param>
    /// <returns></returns>
    bool Remove(string key);


    /// <summary>
    /// 批量删除缓存
    /// </summary>
    /// <param name="key">缓存Key集合</param>
    /// <returns></returns>
    void RemoveAll(IEnumerable<string> keys);




    /// <summary>
    /// 获取缓存
    /// </summary>
    /// <param name="key">缓存Key</param>
    /// <returns></returns>
    T Get<T>(string key) where T : class;



    /// <summary>
    /// 获取缓存
    /// </summary>
    /// <param name="key">缓存Key</param>
    /// <returns></returns>
    string Get(string key);
}

2.2 MemoryCacheService内存缓存

public class MemoryCacheService : ICacheService
{
    protected IMemoryCache _cache;
    public MemoryCacheService(IMemoryCache cache)
    {
        _cache = cache;

    }
    /// <summary>
    /// 验证缓存项是否存在
    /// </summary>
    /// <param name="key">缓存Key</param>
    /// <returns></returns>
    public bool Exists(string key)
    {
        if (key == null)
        {
            throw new ArgumentNullException(nameof(key));
        }
        return _cache.Get(key) != null;
    }

    /// <summary>
    /// 添加缓存
    /// </summary>
    /// <param name="key">缓存Key</param>
    /// <param name="value">缓存Value</param>
    /// <returns></returns>
    public bool Add(string key, object value)
    {
        if (key == null)
        {
            throw new ArgumentNullException(nameof(key));
        }
        if (value == null)
        {
            throw new ArgumentNullException(nameof(value));
        }
        _cache.Set(key, value);
        return Exists(key);
    }

    public bool AddObject(string key, object value, int expireSeconds = -1, bool isSliding = false)
    {
        if (expireSeconds != -1)
        {
            _cache.Set(key,
                value,
                new MemoryCacheEntryOptions()
                .SetSlidingExpiration(new TimeSpan(0, 0, expireSeconds))
                );
        }
        else
        {
            _cache.Set(key, value);
        }

        return true;
    }
    public bool Add(string key, string value, int expireSeconds = -1, bool isSliding = false)
    {
        return AddObject(key, value, expireSeconds, isSliding);
    }
    public void LPush(string key, string val)
    {
    }
    public void RPush(string key, string val)
    {
    }
    public T ListDequeue<T>(string key) where T : class
    {
        return null;
    }
    public object ListDequeue(string key)
    {
        return null;
    }
    public void ListRemove(string key, int keepIndex)
    {
    }
    /// <summary>
    /// 添加缓存
    /// </summary>
    /// <param name="key">缓存Key</param>
    /// <param name="value">缓存Value</param>
    /// <param name="expiresSliding">滑动过期时长（如果在过期时间内有操作，则以当前时间点延长过期时间）</param>
    /// <param name="expiressAbsoulte">绝对过期时长</param>
    /// <returns></returns>
    public bool Add(string key, object value, TimeSpan expiresSliding, TimeSpan expiressAbsoulte)
    {
        _cache.Set(key, value,
                new MemoryCacheEntryOptions()
                .SetSlidingExpiration(expiresSliding)
                .SetAbsoluteExpiration(expiressAbsoulte)
                );

        return Exists(key);
    }
    /// <summary>
    /// 添加缓存
    /// </summary>
    /// <param name="key">缓存Key</param>
    /// <param name="value">缓存Value</param>
    /// <param name="expiresIn">缓存时长</param>
    /// <param name="isSliding">是否滑动过期（如果在过期时间内有操作，则以当前时间点延长过期时间）</param>
    /// <returns></returns>
    public bool Add(string key, object value, TimeSpan expiresIn, bool isSliding = false)
    {
        if (isSliding)
            _cache.Set(key, value,
                new MemoryCacheEntryOptions()
                .SetSlidingExpiration(expiresIn)
                );
        else
            _cache.Set(key, value,
            new MemoryCacheEntryOptions()
            .SetAbsoluteExpiration(expiresIn)
            );

        return Exists(key);
    }



    /// <summary>
    /// 删除缓存
    /// </summary>
    /// <param name="key">缓存Key</param>
    /// <returns></returns>
    public bool Remove(string key)
    {
        if (key == null)
        {
            throw new ArgumentNullException(nameof(key));
        }
        _cache.Remove(key);

        return !Exists(key);
    }
    /// <summary>
    /// 批量删除缓存
    /// </summary>
    /// <param name="key">缓存Key集合</param>
    /// <returns></returns>
    public void RemoveAll(IEnumerable<string> keys)
    {
        if (keys == null)
        {
            throw new ArgumentNullException(nameof(keys));
        }

        keys.ToList().ForEach(item => _cache.Remove(item));
    }
    public string Get(string key)
    {
        return _cache.Get(key)?.ToString();
    }
    /// <summary>
    /// 获取缓存
    /// </summary>
    /// <param name="key">缓存Key</param>
    /// <returns></returns>
    public T Get<T>(string key) where T : class
    {
        if (key == null)
        {
            throw new ArgumentNullException(nameof(key));
        }
        return _cache.Get(key) as T;
    }

    public void Dispose()
    {
        if (_cache != null)
            _cache.Dispose();
        GC.SuppressFinalize(this);
    }


}

2.3 RedisCacheService内存缓存

RedisCacheService redis缓存封装

public class RedisCacheService : ICacheService
{
    public RedisCacheService()
    {
        var csredis = new CSRedisClient(AppSetting.RedisConnectionString);
        RedisHelper.Initialization(csredis);
    }

    /// <summary>
    /// 验证缓存项是否存在
    /// </summary>
    /// <param name="key">缓存Key</param>
    /// <returns></returns>
    public bool Exists(string key)
    {
        if (key == null)
        {
            throw new ArgumentNullException(nameof(key));
        }
        return RedisHelper.Exists(key);
    }

    public void LPush(string key, string val)
    {
        RedisHelper.LPush(key, val);
    }

    public void RPush(string key, string val)
    {
        RedisHelper.RPush(key, val);
    }

    public T ListDequeue<T>(string key) where T : class
    {
        string value = RedisHelper.RPop(key);
        if (string.IsNullOrEmpty(value))
            return null;
        return JsonConvert.DeserializeObject<T>(value);
    }
    public object ListDequeue(string key)
    {
        string value = RedisHelper.RPop(key);
        if (string.IsNullOrEmpty(value))
            return null;
        return value;
    }

    /// <summary>
    /// 移除list中的数据，keepIndex为保留的位置到最后一个元素如list 元素为1.2.3.....100
    /// 需要移除前3个数，keepindex应该为4
    /// </summary>
    /// <param name="key"></param>
    /// <param name="keepIndex"></param>
    public void ListRemove(string key, int keepIndex)
    {
        RedisHelper.LTrim(key, keepIndex, -1);
    }
    public bool Add(string key, string value, int expireSeconds = -1, bool isSliding = false)
    {
        return RedisHelper.Set(key, value, expireSeconds);
    }
    public bool AddObject(string key, object value, int expireSeconds = -1, bool isSliding = false)
    {
        return RedisHelper.Set(key, value, expireSeconds);
    }

    /// <summary>
    /// 删除缓存
    /// </summary>
    /// <param name="key">缓存Key</param>
    /// <returns></returns>
    public bool Remove(string key)
    {
        RedisHelper.Del(key);
        return true;
    }
    /// <summary>
    /// 批量删除缓存
    /// </summary>
    /// <param name="key">缓存Key集合</param>
    /// <returns></returns>
    public void RemoveAll(IEnumerable<string> keys)
    {
        RedisHelper.Del(keys.ToArray());
    }
    /// <summary>
    /// 获取缓存
    /// </summary>
    /// <param name="key">缓存Key</param>
    /// <returns></returns>
    public T Get<T>(string key) where T : class
    {
        return RedisHelper.Get<T>(key);
    }
    /// <summary>
    /// 获取缓存
    /// </summary>
    /// <param name="key">缓存Key</param>
    /// <returns></returns>
    public string Get(string key)
    {
        return RedisHelper.Get(key);
    }
    public void Dispose()
    {
    }
}