Redis 官网上可以找到很多针对 C# 的类库支持，这里我们选择了 ServiceStack.Redis 这个客户端，但是 ServiceStack.Redis 有个连接数限制，需要修改源码，另外一个用的比较多的是 StackExchange.Redis，这里不做介绍。
RedisConfiguration 类：
///
/// 表示配置文件中的 Redis 配置节。
///
public sealed class RedisConfiguration : ConfigurationSection
{
///
/// 检索当前应用程序默认配置的 Redis 配置节。
///
/// 指定的 Redis 配置节对象，或者，如果该节不存在，则为 null。
public static RedisConfiguration GetConfig()
{
RedisConfiguration section = (RedisConfiguration)ConfigurationManager.GetSection("RedisConfig");
return section;
}
///
/// 检索当前应用程序默认配置的 Redis 配置节。
///
/// 配置节的路径和名称。
/// 指定的 Redis 配置节对象，或者，如果该节不存在，则为 null。
public static RedisConfiguration GetConfig(string sectionName)
{
RedisConfiguration section = (RedisConfiguration)ConfigurationManager.GetSection("RedisConfig");
if (section == null)
throw new ConfigurationErrorsException("Section " + sectionName + " is not found.");
return section;
}
///
/// 获取或设置用于写入的 Redis 服务器地址。
///
[ConfigurationProperty("WriteServerList", IsRequired = false)]
public string WriteServerHosts
{
get
{
return (string)base["WriteServerList"];
}
set
{
base["WriteServerList"] = value;
}
}
///
/// 获取或设置用于读取的 Redis 服务器的主机地址。
///
[ConfigurationProperty("ReadServerList", IsRequired = false)]
public string ReadServerHosts
{
get
{
return (string)base["ReadServerList"];
}
set
{
base["ReadServerList"] = value;
}
}
///
/// 获取或设置 Redis Sentinel 服务器的主机地址。
///
[ConfigurationProperty("SentinelServerList", IsRequired = false)]
public string SentinelServerHosts
{
get
{
return (string)base["SentinelServerList"];
}
set
{
base["SentinelServerList"] = value;
}
}
///
/// 获取或设置 Redis Sentinel 服务器的密码。
///
[ConfigurationProperty("SentinelPassword", IsRequired = false)]
public string SentinelPassword
{
get
{
return (string)base["SentinelPassword"];
}
set
{
base["SentinelPassword"] = value;
}
}
///
/// 获取或设置 Redis 主服务器的名称。
///
[ConfigurationProperty("MasterName", IsRequired = false)]
public string MasterName
{
get
{
string masterName = (string)base["MasterName"];
return String.IsNullOrEmpty(masterName) ? "master" : masterName;
}
set
{
base["MasterName"] = value;
}
}
///
/// 获取或设置 Sentinel 的默认数据库。
///
[ConfigurationProperty("SentinelDb", IsRequired = false, DefaultValue = 0)]
public int SentinelDb
{
get
{
int sentinelDb = (int)base["SentinelDb"];
return sentinelDb >= 0 ? sentinelDb : 0;
}
set
{
base["SentinelDb"] = value;
}
}
///
/// 最大写入连接池大小。
///
[ConfigurationProperty("MaxWritePoolSize", IsRequired = false, DefaultValue = 5)]
public int MaxWritePoolSize
{
get
{
int maxWritePoolSize = (int)base["MaxWritePoolSize"];
return maxWritePoolSize > 0 ? maxWritePoolSize : 5;
}
set
{
base["MaxWritePoolSize"] = value;
}
}
///
/// 最大读取连接池大小。
///
[ConfigurationProperty("MaxReadPoolSize", IsRequired = false, DefaultValue = 5)]
public int MaxReadPoolSize
{
get
{
int maxReadPoolSize = (int)base["MaxReadPoolSize"];
return maxReadPoolSize > 0 ? maxReadPoolSize : 5;
}
set
{
base["MaxReadPoolSize"] = value;
}
}
///
/// 自动重启。
///
[ConfigurationProperty("AutoStart", IsRequired = false, DefaultValue = true)]
public bool AutoStart
{
get
{
return (bool)base["AutoStart"];
}
set
{
base["AutoStart"] = value;
}
}
///
/// 本地缓存到期时间，单位：秒。
///
[ConfigurationProperty("CacheExpires", IsRequired = false, DefaultValue = 36000)]
public int CacheExpires
{
get
{
return (int)base["CacheExpires"];
}
set
{
base["CacheExpires"] = value;
}
}
///
/// 是否记录日志，该设置仅用于排查 Redis 运行时出现的问题，如 Redis 工作正常，请关闭该项。
///
[ConfigurationProperty("RecordeLog", IsRequired = false, DefaultValue = false)]
public bool RecordeLog
{
get
{
return (bool)base["RecordeLog"];
}
set
{
base["RecordeLog"] = value;
}
}
}
RedisKeys 类定义全局 Key：
///
/// 全局 Key 定义。
///
public static class RedisKeys
{
#region 广告相关...
///
/// 指定城市唯一编号指定唯一广告编号的信息实体对象，{0}：指定城市唯一编号，{1}：指定广告编码。
///
public static readonly string ADVERTISEMENTSEAT_CITY_BAIDUADID = "AdvertisementSeat_City_{0}_BaiDuAdId_{1}";
///
/// 指定城市唯一编号指定广告投放目标的信息实体对象，{0}：指定城市唯一编号，{1}：指定广告投放目标。
///
public static readonly string ADVERTISEMENTSEAT_CITY_BAIDUADID_TARGET = "AdvertisementSeat_City_{0}_Target_{1}";
///
/// 指定城市唯一编号指定唯一广告编号的信息实体对象，{0}：指定城市唯一编号，{1}：指定产品类型编码。
///
public static readonly string ADVERTISEMENTSEAT_CITY_CONDITION = "AdvertisementSeat_City_{0}_Condition_{1}";
#endregion
}RedisConnectType 类定义 Redis 建立连接的方式，连接池模式，及时连接及时释放模式：
///
/// 定义 Redis 建立连接的方式，连接池模式，及时连接及时释放模式。
///
public enum RedisConnectType
{
///
/// 连接池链接方式。
///
PooledRedisClient,
///
/// 短连接方式，用完就释放的模式。
///
ShortConnectClient
}
RedisExpires 中统一定义了 Redis 数据的有效时间：
///
/// Redis 有效时间（单位：分钟）定义类。
///
public static class RedisExpires
{
///
/// 1 分钟。
///
public static readonly int ONE_MINUTE = 1;
///
/// 10 分钟。
///
public static readonly int TEN_MINUTE = 10;
///
/// 半小时。
///
public static readonly int HALF_HOUR = 30;
///
/// 1 小时。
///
public static readonly int ONE_HOUR = 60;
///
/// 半天。
///
public static readonly int HALF_DAY = 60 * 12;
///
/// 1 天。
///
public static readonly int ONE_DAY = 60 * 24;
///
/// 1 周。
///
public static readonly int ONE_WEEK = 7 * 60 * 24;
///
/// 1 个月。
///
public static readonly int ONE_MONTH = 30 * 60 * 24;
}RedisManager 类中提供了常用的操作：
///
/// 提供一组用于 Redis 连接池管理对象的工具和方法。
///
public sealed class RedisManager
{
///
/// 声明 Redis 配置信息。
///
private static RedisConfiguration _redisConfiguration = RedisConfiguration.GetConfig();
///
/// 声明 Redis 客户端连接的线程安全池对象。
///
private static IRedisClientsManager _redisClientsManager = null;
/////
///// 建立 Redis 连接的方式（默认是连接池的方式）。
/////
//private SoukeRedisConnectType ConnnectType = SoukeRedisConnectType.PooledRedisClient;
/////
///// ip
/////
//private string RedisServerIP = "";
/////
///// 端口
/////
//private int RedisServerPort = 6379;
/////
///// 数据库编号
/////
//private int RedisServerDb = 0;
///
/// 声明 _lockObject 对象。
///
private object _lockObject = new object();
///
/// 初始化 Redis 连接池管理对象。
///
static RedisManager()
{
CreateManager();
}
///
/// 创建 Redis 连接池管理对象。
///
private static void CreateManager()
{
string[] sentinelServerHosts = SplitServerHosts(_soukeRedisConfiguration.SentinelServerHosts, ",");
var redisSentinel = new RedisSentinel(sentinelServerHosts, _soukeRedisConfiguration.MasterName);
_redisClientsManager = redisSentinel.Start();
}
///
/// 取得服务器主机地址集合。
///
/// 服务器主机地址。
/// 分隔符。
/// 服务器主机地址集合。
private static string[] SplitServerHosts(string serverHosts, string split)
{
return serverHosts.Split(split.ToArray());
}
///
/// 获取 Redis 客户端缓存操作对象。
///
public static IRedisClient GetClient()
{
if (_redisClientsManager == null)
CreateManager();
var redisClient = _redisClientsManager.GetClient();
redisClient.Password = _soukeRedisConfiguration.SentinelPassword;
#if(DEBUG)
redisClient.Db = _soukeRedisConfiguration.SentinelDb;
#endif
return redisClient;
}
///
/// 刷新全部数据。
///
public static void FlushAll()
{
using (IRedisClient redis = GetClient())
{
redis.FlushAll();
}
}
#region 项...
///
/// 设置指定的项到指定的键中。
///
/// 指定的项类型。
/// 指定的键。
/// 指定的项。
/// 如果设置成功，则为 true；否则为 false。
public static bool ItemSet(string key, T t)
{
using (IRedisClient redis = GetClient())
{
return redis.Set(key, t);
}
}
///
/// 设置指定的项到指定的键中。
///
/// 指定的项类型。
/// 指定的键。
/// 指定的项。
/// 指定的有效期（单位：分钟）。
/// 如果设置成功，则为 true；否则为 false。
public static bool ItemSetExpire(string key, T t, int expire)
{
using (IRedisClient redis = GetClient())
{
return redis.Set(key, t, DateTime.Now.Add(TimeSpan.FromMinutes(expire)));
}
}
///
/// 获取指定的键的项。
///
/// 指定的项类型。
/// 指定的键。
/// 如果存在该项，则返回该项，否则返回 null。
public static T ItemGet(string key) where T : class
{
using (IRedisClient redis = GetClient())
{
return redis.Get(key);
}
}
///
/// 移除指定的键的项。
///
/// 指定的键。
/// 如果移除成功，则为 true；否则为 false。
public static bool ItemRemove(string key)
{
using (IRedisClient redis = GetClient())
{
return redis.Remove(key);
}
}
#endregion
#region 列表...
///
/// 添加项到指定键的列表。
///
/// 指定的项类型。
/// 指定的键。
/// 指定的项。
public static void ListAdd(string key, T t)
{
using (IRedisClient redis = GetClient())
{
var redisTypedClient = redis.As();
redisTypedClient.AddItemToList(redisTypedClient.Lists[key], t);
}
}
///
/// 将指定的对象集合的元素添加到指定键的列表末尾。
///
/// 指定的项类型。
/// 指定的键。
/// 指定的项的集合。
public static void ListAddRange(string key, List tList)
{
using (IRedisClient redis = GetClient())
{
var redisTypedClient = redis.As();
redisTypedClient.Lists[key].AddRange(tList);
}
}
///
/// 从指定键的列表中移除指定的项。
///
/// 指定的项类型。
/// 指定的键。
/// 指定的项。
/// 返回一个值，该值表示是否移除成功。
public static bool ListRemove(string key, T t)
{
using (IRedisClient redis = GetClient())
{
var redisTypedClient = redis.As();
return redisTypedClient.RemoveItemFromList(redisTypedClient.Lists[key], t) > 0;
}
}
///
/// 从指定键的列表中移除所有的项。
///
/// 指定的项类型。
/// 指定的键。
public static void ListRemoveAll(string key)
{
using (IRedisClient redis = GetClient())
{
var redisTypedClient = redis.As();
redisTypedClient.Lists[key].RemoveAll();
}
}
///
/// 获取指定键的列表中实际包含的元素数。
///
/// 指定的键。
/// 指定的键中实际包含的元素数。
public static int ListCount(string key)
{
using (IRedisClient redis = GetClient())
{
return (int)redis.GetListCount(key);
}
}
///
/// 从指定键的列表中获取指定范围的元素。
///
/// 指定项的类型。
/// 指定的键。
/// 范围开始处的从零开始的索引。
/// 范围中的元素数。
/// 指定键的列表中的范围的元素。
public static List ListGetRange(string key, int index, int count)
{
using (IRedisClient redis = GetClient())
{
var c = redis.As();
return c.Lists[key].GetRange(index, index + count - 1);
}
}
///
/// 获取指定键的列表中的所有元素。
///
/// 指定的项类型。
/// 指定的键。
/// 指定键的列表中的范围的元素。
public static List ListGetAll(string key)
{
using (IRedisClient redis = GetClient())
{
var c = redis.As();
return c.Lists[key].GetRange(0, c.Lists[key].Count);
}
}
///
/// 分页获取指定键的列表中的元素。
///
/// 指定的项类型。
/// 指定的键。
/// 指定的分页索引。
/// 指定的分页大小。
/// 指定键的列表中的范围的元素。
public static List ListGetAll(string key, int pageIndex, int pageSize)
{
int start = pageSize * (pageIndex - 1);
return ListGetRange(key, start, pageSize);
}
///
/// 设置指定键的列表的有效期。
///
/// 指定的键。
/// 有效期。
public static void ListSetExpire(string key, DateTime datetime)
{
using (IRedisClient redis = GetClient())
{
redis.ExpireEntryAt(key, datetime);
}
}
#endregion
#region 集合...
///
/// 将一个或多个元素加入到集合指定的键中，已经存在于集合的元素将被忽略。
///
/// 指定的项类型。
/// 指定的键。
/// 指定的项。
public static void SetAdd(string key, T t)
{
using (IRedisClient redis = GetClient())
{
var redisTypedClient = redis.As();
redisTypedClient.Sets[key].Add(t);
}
}
///
/// 获取指定的键的集合中实际包含的元素数。
///
/// 指定的项类型。
/// 指定的键。
/// 指定的键的集合中实际包含的元素数。
public static int SetCount(string key)
{
using (IRedisClient redis = GetClient())
{
var redisTypedClient = redis.As();
return redisTypedClient.Sets[key].Count();
}
}
///
/// 确定某项是否在指定键的集合中。
///
/// 指定的项类型。
/// 指定的键。
/// 指定的项。
/// 如果存在该项，则为 true；否则为 false。
public static bool SetContains(string key, T t)
{
using (IRedisClient redis = GetClient())
{
var redisTypedClient = redis.As();
return redisTypedClient.Sets[key].Contains(t);
}
}
///
/// 从指定键的集合中移除特定对象的第一个匹配项。
///
/// 指定的项类型。
/// 指定的键。
/// 指定的项。
/// 如果移除成功，则为 true；否则为 false。
public static bool SetRemove(string key, T t)
{
using (IRedisClient redis = GetClient())
{
var redisTypedClient = redis.As();
return redisTypedClient.Sets[key].Remove(t);
}
}
///
/// 获取指定键的数据集的所有项。
///
/// 指定的项类型。
/// 指定的键。
/// 指定键的数据集的所有项
public static IList SetGetAll(string key)
{
List result = new List();
using (IRedisClient redis = GetClient())
{
var redisTypedClient = redis.As();
var sets = redisTypedClient.Sets[key];
if (sets != null && sets.Count > 0)
{
foreach (var item in sets)
{
result.Add(item);
}
}
}
return result;
}
#endregion
#region 哈希表...
///
/// 确定某项是否在指定键的哈希表中。
///
/// 指定的项类型。
/// 指定的键。
/// 数据项的键。
/// 如果存在该项，则为 true；否则为 false。
public static bool HashSetContains(string key, string dataKey)
{
using (IRedisClient redis = GetClient())
{
return redis.HashContainsEntry(key, dataKey);
}
}
///
/// 设置指定的项到指定键的哈希表中。
///
/// 指定的项类型。
/// 指定的键。
/// 数据项的键。
/// 如果设置成功，则为 true；否则为 false。
public static bool HashSetAdd(string key, string dataKey, T t)
{
using (IRedisClient redis = GetClient())
{
string value = JsonSerializer.SerializeToString(t);
return redis.SetEntryInHash(key, dataKey, value);
}
}
///
/// 移除哈希表中指定键的项。
///
/// 指定的项类型。
/// 指定的键。
/// 数据项的键。
/// 如果移除成功，则为 true；否则为 false。
public static bool HashSetRemove(string key, string dataKey)
{
using (IRedisClient redis = GetClient())
{
return redis.RemoveEntryFromHash(key, dataKey);
}
}
///
/// 移除哈希表中的所有项。
///
/// 指定的项类型。
/// 指定的键。
/// 数据项的键。
/// 如果移除成功，则为 true；否则为 false。
public static bool HashSetRemoveAll(string key)
{
using (IRedisClient redis = GetClient())
{
return redis.Remove(key);
}
}
///
/// 获取哈希表中的指定键的项。
///
/// 指定的项类型。
/// 指定的键。
/// 数据项的键。
/// 指定键的哈希表的项。
public static T HashSetGet(string key, string dataKey)
{
using (IRedisClient redis = GetClient())
{
string value = redis.GetValueFromHash(key, dataKey);
return JsonSerializer.DeserializeFromString(value);
}
}
///
/// 获取指定键的哈希表的所有项。
///
/// 指定的项类型。
/// 指定的键。
/// 指定键的哈希表的所有项。
public static List HashSetGetAll(string key)
{
using (IRedisClient redis = GetClient())
{
var list = redis.GetHashValues(key);
if (list != null && list.Count > 0)
{
List result = new List();
foreach (var item in list)
{
var value = JsonSerializer.DeserializeFromString(item);
result.Add(value);
}
return result;
}
return null;
}
}
///
/// 设置指定键的哈希表的有效期。
///
/// 指定的键。
/// 指定的有效期时间（单位：分钟）。
public static void HashSetExpire(string key, int expire)
{
using (IRedisClient redis = GetClient())
{
redis.ExpireEntryAt(key, DateTime.Now.Add(TimeSpan.FromMinutes(expire)));
}
}
#endregion
#region 有序集合...
///
/// 添加指定项到指定键的有序集合。
///
/// 指定的项类型。
/// 指定的键。
/// 指定的项。
/// 如果成功添加，则为 true；否则为 false。
public static bool SortedSetAdd(string key, T t)
{
using (IRedisClient redis = GetClient())
{
string value = JsonSerializer.SerializeToString(t);
return redis.AddItemToSortedSet(key, value);
}
}
///
/// 添加指定项到指定键的有序集合，评分用于排序。如果该元素已经存在，则根据评分更新该元素的顺序。
///
/// 指定的项类型。
/// 指定的键。
/// 指定的项。
/// 用于排序的评分值。
/// 如果成功添加，则为 true；否则为 false。
public static bool SortedSetAdd(string key, T t, double score)
{
using (IRedisClient redis = GetClient())
{
string value = JsonSerializer.SerializeToString(t);
return redis.AddItemToSortedSet(key, value, score);
}
}
///
/// 从指定键的有序集合中移除指定的元素。
///
/// 指定的项类型。
/// 指定的键。
/// 指定的项。
/// 如果成功移除，则为 true；否则为 false。
public static bool SortedSetRemove(string key, T t)
{
using (IRedisClient redis = GetClient())
{
string value = ServiceStack.Text.JsonSerializer.SerializeToString(t);
return redis.RemoveItemFromSortedSet(key, value);
}
}
///
/// 从指定键的有序集合尾部移除指定的索引后的匹配项。
///
/// 指定的键。
/// 保留的条数。
/// 移除的元素数量。
public static int SortedSetTrim(string key, int size)
{
using (IRedisClient redis = GetClient())
{
return (int)redis.RemoveRangeFromSortedSet(key, size, 9999999);
}
}
///
/// 获取指定的键的有序集合中实际包含的元素数。
///
/// 指定的键。
/// 指定的键的有序集合中实际包含的元素数。
public static int SortedSetCount(string key)
{
using (IRedisClient redis = GetClient())
{
return (int)redis.GetSortedSetCount(key);
}
}
///
/// 分页获取指定键的有序集合中的元素。
///
/// 指定的项类型。
/// 指定的键。
/// 指定的分页索引。
/// 指定的分页大小。
/// 指定键的有序集合中的元素集合。
public static List SortedSetGetList(string key, int pageIndex, int pageSize)
{
using (IRedisClient redis = GetClient())
{
var list = redis.GetRangeFromSortedSet(key, (pageIndex - 1) * pageSize, pageIndex * pageSize - 1);
if (list != null && list.Count > 0)
{
List result = new List();
foreach (var item in list)
{
var data = ServiceStack.Text.JsonSerializer.DeserializeFromString(item);
result.Add(data);
}
return result;
}
}
return null;
}
///
/// 获取指定键的有序集合中的所有元素。
///
/// 指定的项类型。
/// 指定的键。
/// 指定键的有序集合中的元素集合。
public static List SortedSetGetListALL(string key)
{
using (IRedisClient redis = GetClient())
{
var list = redis.GetRangeFromSortedSet(key, 0, 9999999);
if (list != null && list.Count > 0)
{
List result = new List();
foreach (var item in list)
{
var data = JsonSerializer.DeserializeFromString(item);
result.Add(data);
}
return result;
}
}
return null;
}
///
/// 设置指定键的有序集合的有效期。
///
/// 指定的键。
/// 指定的有效期（单位：分钟）。
public static void SortedSetSetExpire(string key, int expire)
{
using (IRedisClient redis = GetClient())
{
redis.ExpireEntryAt(key, DateTime.Now.Add(TimeSpan.FromMinutes(expire)));
}
}
///
/// 获取指定键的有序集合中的指定元素的评分。
///
/// 指定的项类型。
/// 指定的键。
/// 指定的项。
/// 指定键的有序集合中的指定元素的评分。
public static double SortedSetGetItemScore(string key, T t)
{
using (IRedisClient redis = GetClient())
{
var data = ServiceStack.Text.JsonSerializer.SerializeToString(t);
return redis.GetItemScoreInSortedSet(key, data);
}
}
#endregion
#region 二进制...
///
/// 设置 BitMap 值，返回 0 或 1 是成功，返回 -1 是失败。
///
/// 指定的键。
/// 偏移量。
/// 值只能是 0 或 1，其它的值会报错
/// 返回 0 或 1 是成功，返回 -1 是失败。
public static long BitSet(string key, int offset, int value)
{
using (IRedisClient redis = GetClient())
{
var rc = redis as RedisClient;
if (rc != null)
{
return rc.SetBit(key, offset, value);
}
return -1;
}
}
///
/// 获取 BitMap 值，返回 0 或 1 是成功，返回 -1 是失败。
///
/// 指定的键。
/// 偏移量。
/// 返回 0 或 1 是成功，返回 -1 是失败。
public static long BitGet(string key, int offset)
{
using (IRedisClient redis = GetClient())
{
var rc = redis as RedisClient;
if (rc != null)
{
return rc.GetBit(key, offset);
}
return -1;
}
}
public bool ByteSet(string key, T t)
{
bool result = false;
if (t != null)
{
MemoryStream ms = new MemoryStream();
Serialize(t, ms);
byte[] data = ms.ToArray();
using (IRedisClient redis = GetClient())
{
return redis.Set(key, data);
}
}
return result;
}
///
/// 写入一个实体类T，将其转换成二制进存储，并且数据过期时间一到则立刻删除
///
/// 指定的项类型。
/// 指定的键。
///
///
/// (string key, T t, DateTime Expire)
{
bool flag = false;
if (t != null)
{
MemoryStream ms = new MemoryStream();
Serialize(t, ms);
byte[] data = ms.ToArray();
using (IRedisClient redis = GetClient())
{
TimeSpan ts = Expire - DateTime.Now;
flag = redis.Set(key, data, ts);
}
}
return flag;
}
///
/// 获取 key 值为 key 的实体类 T。
///
/// 指定的项类型。
/// 指定的键。
/// (string key)
{
using (IRedisClient redis = GetClient())
{
byte[] data = redis.Get(key);
if (data == null || data.Length == 0)
{
return default(T);
}
using (MemoryStream ms = new MemoryStream())
{
ms.Write(data, 0, data.Length);
ms.Position = 0;
return Deserialize(ms);
}
}
}
#endregion
#region 其他方法...
///
/// 获取当前服务器中的所有 Key。
///
/// 当前服务器中的所有 Key 的集合。
public static List GetAllKeys()
{
using (IRedisClient redis = GetClient())
{
return redis.GetAllKeys();
}
}
///
/// 移除指定集合中的所有 Key。
///
/// 指定的 Key 集合。
public static void RemoveAll(IEnumerable keys)
{
using (IRedisClient redis = GetClient())
{
redis.RemoveAll(keys);
}
}
///
/// 确定指定的键是否在 Redis 数据库中。
///
/// 指定的键。
/// 若存在指定的键，则返回 true，否则返回 false。
public static bool ContainsKey(string key)
{
using (IRedisClient redis = GetClient())
{
return redis.ContainsKey(key);
}
}
///
/// 获取当前数据库服务器中的指定的 Key。
///
/// 指定的键。
/// 若移除指定的键成功，则返回 true，否则返回 false。
public static bool Remove(string key)
{
using (IRedisClient redis = GetClient())
{
return redis.Remove(key);
}
}
///
/// 获取当前 Redis 信息。
///
/// 当前 Redis 信息。
public Dictionary GetInfo()
{
using (IRedisClient redis = GetClient())
{
return redis.Info;
}
}
///
/// 将指定的对象序列化成二进制对象。
///
/// 指定的项类型。
/// 指定的对象。
/// 序列化的二进制对象。
private static void Serialize(T obj, Stream stream)
{
if (stream == null)
throw new ArgumentNullException("stream");
var formatter = new BinaryFormatter();
formatter.Serialize(stream, obj);
}
///
/// 将指定的二进制对象反序列化成对象。
///
/// 指定的项类型。
/// 指定的对象。
/// 序列化的二进制对象。
/// 反序列化的对象。
public static T Deserialize(Stream stream)
{
if (stream == null)
throw new ArgumentNullException("stream");
var formatter = new BinaryFormatter();
return (T)formatter.Deserialize(stream);
}
#endregion
}