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

前言

内存缓存是一种将数据存储在内存中的技术，可以提高数据的读取速度和响应速度。常见的内存缓存技术包括 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()
{
}
}