c#--Redis帮助类
2024-03-22 00:35:10
最近一直在忙公司的一下项目，也没有太多时间写，所以就分享出所用redis帮助类
using Newtonsoft.Json;
using StackExchange.Redis;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Reflection;
using System.Text;
using ZsqApp.Core.Infrastructure.Extentions;
using ZsqApp.Core.Infrastructure.SysEnum; namespace ZsqApp.Core.Infrastructure.Utilities
{
//**************操作记录******************
//内容描述：Redis帮助类
//***************************************
public static class RedisHelper
{ private static string _strConn = "地址";
private static string _strPwd = "密码"; private static int _strDb = -1;
static ConnectionMultiplexer _redis;
static readonly object _locker = new object(); #region 单例模式
public static ConnectionMultiplexer Manager
{ get
{
if (_redis == null)
{
lock (_locker)
{
if (_redis != null) return _redis;
_redis = GetManager();
return _redis;
}
}
return _redis;
}
} private static ConnectionMultiplexer GetManager(string connectionString = null)
{ if (StringExtension.IsBlank(connectionString))
{
connectionString = _strConn;
}
var options = ConfigurationOptions.Parse(connectionString);
options.Password = _strPwd;
return ConnectionMultiplexer.Connect(options);
}
#endregion #region 辅助方法
/// <summary>
/// 对象序列化成字符串
/// </summary>
/// <typeparam name="T">泛型对象</typeparam>
/// <param name="value"></param>
/// <returns></returns>
private static string ConvertJson<T>(T value)
{
string result = value is string ? value.ToString() : JsonConvert.SerializeObject(value);
return result;
} /// <summary>
/// RedisValue序列化成对象
/// </summary>
/// <typeparam name="T">序列化后的对象</typeparam>
/// <param name="value">RedisValue</param>
/// <returns></returns>
private static T ConvertObj<T>(RedisValue value)
{
if (StringExtension.IsBlank(value))
{
return default(T);
}
else
{
return JsonConvert.DeserializeObject<T>(value);
}
} /// <summary>
/// 多个值序列化成list集合
/// </summary>
/// <typeparam name="T">集合对象</typeparam>
/// <param name="values">RedisValue</param>
/// <returns></returns>
private static List<T> ConvetList<T>(RedisValue[] values)
{
List<T> result = new List<T>();
foreach (var item in values)
{
var model = ConvertObj<T>(item);
if (model != null)
result.Add(model);
}
return result;
} private static RedisKey[] ConvertRedisKeys(List<string> redisKeys, string prefix)
{
if (StringExtension.IsBlank(prefix))
{
return redisKeys.Select(redisKey => (RedisKey)redisKey).ToArray();
}
else
{
return redisKeys.Select(redisKey => (RedisKey)(prefix + ":" + redisKey)).ToArray();
}
} /// <summary>
/// 获取要操作的库
/// </summary>
/// <param name="db">库，0和-1都是第一个库，1是第二个库...</param>
/// <returns></returns>
private static int GetOperationDB(RedisEnum db)
{
if (db == RedisEnum.Default)
{
return _strDb;
}
else
{
return (int)db;
}
} /// <summary>
/// 获得枚举的Description
/// </summary>
/// <param name="value">枚举值</param>
/// <param name="nameInstead">当枚举值没有定义DescriptionAttribute，是否使用枚举名代替，默认是使用</param>
/// <returns>枚举的Description</returns>
private static string GetDescription(this Enum value, Boolean nameInstead = true)
{
Type type = value.GetType();
string name = Enum.GetName(type, value);
if (name == null)
{
return null;
} FieldInfo field = type.GetField(name);
DescriptionAttribute attribute = Attribute.GetCustomAttribute(field, typeof(DescriptionAttribute)) as DescriptionAttribute; if (attribute == null && nameInstead == true)
{
return name;
}
return attribute == null ? null : attribute.Description;
}
#endregion /// <summary>
/// 是否存在
/// </summary>
/// <param name="key">键</param>
/// <param name="folder">目录，默认根目录</param>
/// <param name="db">库，默认读取配置文件</param>
public static bool KeyExists(string key, RedisFolderEnum folder = RedisFolderEnum.Root, RedisEnum db = RedisEnum.Default)
{
try
{
string strFd = GetDescription(folder);
return Manager.GetDatabase(GetOperationDB(db)).KeyExists(StringExtension.IsBlank(strFd) ? key : strFd + ":" + key);
}
catch (Exception)
{
return false;
}
} /// <summary>
/// 设置过期时间
/// </summary>
/// <param name="key">键</param>
/// <param name="min">过期时间，单位：分钟</param>
/// <param name="folder">目录，默认根目录</param>
/// <param name="db">库，默认读取配置文件</param>
public static bool KeyExpire(string key, int min = 600, RedisFolderEnum folder = RedisFolderEnum.Root, RedisEnum db = RedisEnum.Default)
{
try
{
string strFd = GetDescription(folder);
return Manager.GetDatabase(GetOperationDB(db)).KeyExpire(StringExtension.IsBlank(strFd) ? key : strFd + ":" + key, DateTime.Now.AddMinutes(min));
}
catch (Exception)
{
return false;
}
} /// <summary>
/// 修改键
/// </summary>
/// <param name="key">键</param>
/// <param name="newKey">新键</param>
/// <param name="folder">目录，默认根目录</param>
/// <param name="db">库，默认读取配置文件</param>
/// <returns></returns>
public static bool KeyRename(string key, string newKey, RedisFolderEnum folder = RedisFolderEnum.Root, RedisEnum db = RedisEnum.Default)
{
try
{
string strFd = GetDescription(folder);
return Manager.GetDatabase(GetOperationDB(db)).KeyRename(StringExtension.IsBlank(strFd) ? key : strFd + ":" + key, StringExtension.IsBlank(strFd) ? newKey : strFd + ":" + newKey);
}
catch (Exception)
{
return false;
}
} /// <summary>
/// 清空
/// </summary>
/// <param name="key">键</param>
/// <param name="folder">目录，默认根目录</param>
/// <param name="db">库，默认读取配置文件</param>
/// <returns></returns>
public static IEnumerable<RedisKey> AllClear(string key, RedisFolderEnum folder = RedisFolderEnum.Root, RedisEnum db = RedisEnum.Default)
{
return Manager.GetServer(_strConn, _strPwd).Keys(GetOperationDB(db), key);
} /// <summary>
/// 删除
/// </summary>
/// <param name="key">键</param>
/// <param name="folder">目录，默认根目录</param>
/// <param name="db">库，默认读取配置文件</param>
/// <returns></returns>
public static bool KeyDelete(string key, RedisFolderEnum folder = RedisFolderEnum.Root, RedisEnum db = RedisEnum.Default)
{
try
{
string strFd = GetDescription(folder);
return Manager.GetDatabase(GetOperationDB(db)).KeyDelete(StringExtension.IsBlank(strFd) ? key : strFd + ":" + key);
}
catch (Exception)
{
return false;
}
} /// <summary>
/// 批量删除
/// </summary>
/// <param name="keys">键</param>
/// <param name="folder">目录，默认根目录</param>
/// <param name="db">库，默认读取配置文件</param>
/// <returns></returns>
public static long KeyDelete(List<string> keys, RedisFolderEnum folder = RedisFolderEnum.Root, RedisEnum db = RedisEnum.Default)
{
try
{
string strFd = GetDescription(folder);
return Manager.GetDatabase(GetOperationDB(db)).KeyDelete(ConvertRedisKeys(keys, strFd));
}
catch (Exception)
{
return 0;
}
} /// <summary>
/// 缓存单个字符串
/// </summary>
/// <param name="key">键</param>
/// <param name="value">值</param>
/// <param name="expireMinutes">过期时间，单位：分钟</param>
/// <param name="folder">目录，默认根目录</param>
/// <param name="db">库，默认读取配置文件</param>
/// <returns></returns>
public static bool StringSet(string key, string value, int expireMinutes = 600, RedisFolderEnum folder = RedisFolderEnum.Root, RedisEnum db = RedisEnum.Default)
{
string strFd = GetDescription(folder);
return Manager.GetDatabase(GetOperationDB(db)).StringSet(StringExtension.IsBlank(strFd) ? key : strFd + ":" + key, value, TimeSpan.FromMinutes(expireMinutes));
} /// <summary>
/// 批量缓存字符串
/// </summary>
/// <param name="keysStr">键</param>
/// <param name="valuesStr">值</param>
/// <param name="folder">目录，默认根目录</param>
/// <param name="db">库，默认读取配置文件</param>
/// <returns></returns>
public static bool StringSet(string[] keysStr, string[] valuesStr, RedisFolderEnum folder = RedisFolderEnum.Root, RedisEnum db = RedisEnum.Default)
{
string strFd = GetDescription(folder);
var vCount = keysStr.Length;
var vKeyValuePair = new KeyValuePair<RedisKey, RedisValue>[vCount];
for (int i = 0; i < vCount; i++)
{
vKeyValuePair[i] = new KeyValuePair<RedisKey, RedisValue>(StringExtension.IsBlank(strFd) ? keysStr[i] : strFd + ":" + keysStr[i], valuesStr[i]);
}
return Manager.GetDatabase(GetOperationDB(db)).StringSet(vKeyValuePair);
} /// <summary>
/// 缓存限时对象
/// </summary>
/// <typeparam name="T">类型</typeparam>
/// <param name="key">键</param>
/// <param name="obj">值</param>
/// <param name="expireMinutes">过期时间，单位：分钟</param>
/// <param name="folder">目录，默认根目录</param>
/// <param name="db">库，默认读取配置文件</param>
/// <returns></returns>
public static bool StringSet<T>(string key, T obj, int expireMinutes = 600, RedisFolderEnum folder = RedisFolderEnum.Root, RedisEnum db = RedisEnum.Default)
{
string strFd = GetDescription(folder);
return Manager.GetDatabase(GetOperationDB(db)).StringSet(StringExtension.IsBlank(strFd) ? key : strFd + ":" + key, JsonHelper.SerializeObject(obj), TimeSpan.FromMinutes(expireMinutes));
} /// <summary>
/// 缓存对象
/// </summary>
/// <typeparam name="T">类型</typeparam>
/// <param name="key">键</param>
/// <param name="obj">值</param>
/// <param name="folder">目录，默认根目录</param>
/// <param name="db">库，默认读取配置文件</param>
/// <returns></returns>
public static bool StringSet<T>(string key, T obj, RedisFolderEnum folder = RedisFolderEnum.Root, RedisEnum db = RedisEnum.Default)
{
string strFd = GetDescription(folder);
return Manager.GetDatabase(GetOperationDB(db)).StringSet(StringExtension.IsBlank(strFd) ? key : strFd + ":" + key, JsonHelper.SerializeObject(obj));
} /// <summary>
/// 根据key获取值
/// </summary>
/// <param name="key">键</param>
/// <param name="folder">目录，默认根目录</param>
/// <param name="db">库，默认读取配置文件</param>
/// <returns></returns>
public static string StringGet(string key, RedisFolderEnum folder = RedisFolderEnum.Root, RedisEnum db = RedisEnum.Default)
{
string strFd = GetDescription(folder);
return Manager.GetDatabase(GetOperationDB(db)).StringGet(StringExtension.IsBlank(strFd) ? key : strFd + ":" + key);
} /// <summary>
/// 批量根据key获取
/// </summary>
/// <param name="keys">键</param>
/// <param name="folder">目录，默认根目录</param>
/// <param name="db">库，默认读取配置文件</param>
/// <returns></returns>
public static RedisValue[] StringGet(List<string> keys, RedisFolderEnum folder = RedisFolderEnum.Root, RedisEnum db = RedisEnum.Default)
{
string strFd = GetDescription(folder);
return Manager.GetDatabase(GetOperationDB(db)).StringGet(ConvertRedisKeys(keys, strFd));
} /// <summary>
/// 根据key获取单个对象
/// </summary>
/// <typeparam name="T">类型</typeparam>
/// <param name="key">键</param>
/// <param name="folder">目录，默认根目录</param>
/// <param name="db">库，默认读取配置文件</param>
/// <returns></returns>
public static T StringGet<T>(string key, RedisFolderEnum folder = RedisFolderEnum.Root, RedisEnum db = RedisEnum.Default)
{
string strFd = GetDescription(folder);
string vValue = Manager.GetDatabase(GetOperationDB(db)).StringGet(StringExtension.IsBlank(strFd) ? key : strFd + ":" + key);
return ConvertObj<T>(vValue);
} /// <summary>
/// 入栈（后插入的在List前面）
/// </summary>
/// <typeparam name="T">类型</typeparam>
/// <param name="key">键</param>
/// <param name="value">值</param>
/// <param name="folder">目录，默认根目录</param>
/// <param name="db">库，默认读取配置文件</param>
public static long ListLeftPush<T>(string key, T value, RedisFolderEnum folder = RedisFolderEnum.Root, RedisEnum db = RedisEnum.Default)
{
string strFd = GetDescription(folder);
return Manager.GetDatabase(GetOperationDB(db)).ListLeftPush(StringExtension.IsBlank(strFd) ? key : strFd + ":" + key, ConvertJson(value));
} /// <summary>
/// 批量入栈（后插入的在List前面）
/// </summary>
/// <typeparam name="T">类型</typeparam>
/// <param name="key">键</param>
/// <param name="values">值</param>
/// <param name="folder">目录，默认根目录</param>
/// <param name="db">库，默认读取配置文件</param>
/// <returns></returns>
public static long ListLeftPush<T>(string key, List<T> values, RedisFolderEnum folder = RedisFolderEnum.Root, RedisEnum db = RedisEnum.Default)
{
string strFd = GetDescription(folder);
var vRedisValues = values.Select(m => (RedisValue)ConvertJson(m)).ToArray();
return Manager.GetDatabase(GetOperationDB(db)).ListLeftPush(StringExtension.IsBlank(strFd) ? key : strFd + ":" + key, vRedisValues);
} /// <summary>
/// 出栈（删除最前面的一个元素并返回）
/// </summary>
/// <typeparam name="T">类型</typeparam>
/// <param name="key">键</param>
/// <param name="folder">目录，默认根目录</param>
/// <param name="db">库，默认读取配置文件</param>
/// <returns></returns>
public static T ListLeftPop<T>(string key, RedisFolderEnum folder = RedisFolderEnum.Root, RedisEnum db = RedisEnum.Default)
{
string strFd = GetDescription(folder);
var vRedisValues = Manager.GetDatabase(GetOperationDB(db)).ListLeftPop(StringExtension.IsBlank(strFd) ? key : strFd + ":" + key);
return ConvertObj<T>(vRedisValues);
} /// <summary>
/// 入队（后插入的在List后面）
/// </summary>
/// <typeparam name="T">类型</typeparam>
/// <param name="key">键</param>
/// <param name="value">值</param>
/// <param name="folder">目录，默认根目录</param>
/// <param name="db">库，默认读取配置文件</param>
public static long ListRightPush<T>(string key, T value, RedisFolderEnum folder = RedisFolderEnum.Root, RedisEnum db = RedisEnum.Default)
{
string strFd = GetDescription(folder);
return Manager.GetDatabase(GetOperationDB(db)).ListRightPush(StringExtension.IsBlank(strFd) ? key : strFd + ":" + key, ConvertJson(value));
} /// <summary>
/// 批量入队（后插入的在List后面）
/// </summary>
/// <typeparam name="T">类型</typeparam>
/// <param name="key">键</param>
/// <param name="values">值</param>
/// <param name="folder">目录，默认根目录</param>
/// <param name="db">库，默认读取配置文件</param>
/// <returns></returns>
public static long ListRightPush<T>(string key, List<T> values, RedisFolderEnum folder = RedisFolderEnum.Root, RedisEnum db = RedisEnum.Default)
{
string strFd = GetDescription(folder);
var vRedisValues = values.Select(m => (RedisValue)ConvertJson(m)).ToArray();
return Manager.GetDatabase(GetOperationDB(db)).ListRightPush(StringExtension.IsBlank(strFd) ? key : strFd + ":" + key, vRedisValues);
} /// <summary>
/// 获取
/// <typeparam name="T">类型</typeparam>
/// <param name="key">键</param>
/// <param name="start">索引开始</param>
/// <param name="stop">索引结束</param>
/// <param name="folder">目录，默认根目录</param>
/// <param name="db">库，默认读取配置文件</param>
/// <returns></returns>
public static List<T> ListRange<T>(string key, long start = 0, long stop = -1, RedisFolderEnum folder = RedisFolderEnum.Root, RedisEnum db = RedisEnum.Default)
{
string strFd = GetDescription(folder);
var vRedisValues = Manager.GetDatabase(GetOperationDB(db)).ListRange(StringExtension.IsBlank(strFd) ? key : strFd + ":" + key, start, stop);
return ConvetList<T>(vRedisValues);
} /// <summary>
/// 获取个数
/// </summary>
/// <param name="key">键</param>
/// <param name="folder">目录，默认根目录</param>
/// <param name="db">库，默认读取配置文件</param>
/// <returns></returns>
public static long ListLength(string key, RedisFolderEnum folder = RedisFolderEnum.Root, RedisEnum db = RedisEnum.Default)
{
string strFd = GetDescription(folder);
return Manager.GetDatabase(GetOperationDB(db)).ListLength(StringExtension.IsBlank(strFd) ? key : strFd + ":" + key);
} }
}
最新文章
- Win10 UI介绍之Titlebar
- Linux从零单排（一）：Google Chrome的安装
- 实现浏览器打开图片的url默认是下载
- 编译原理简单语法分析器（first,follow,分析表）源码下载
- Android消息机制源码分析
- WinSCP 连接 Ubuntu 拒绝的问题
- C#巧用Excel模版变成把Table打印出来
- C++-copy constructor、copy-assignment operator、destructor
- js获取地址栏url以及获取url参数
- pig报错
- CentOS7修改网卡名称，禁用ipv6
- CNN中的经典结构之AlexNet
- Python捕捉系统信号
- 【密码技术】Part 4 SSL/TLS
- Machine Learning 神器 - sklearn
- IDEA配置maven,jdk,编码
- 【转】Java学习---内存泄露与溢出的区别
- VMware上安装VMware tools
- Oracle常见的几种登录方式
- 【Python】Python中子类怎样调用父类方法