【redis学习总结】C# StackExchange Redis

链接: https://pan.baidu.com/s/1lZ0vGsQb4CHrPIdO26Q8pg 密码: fvnb

文件在这里，有兴趣可以看看
先一步一步封装吧。
首先是ConfigurationHelperpublic static class ConfigurationHelper
{
internal static T Get<T>(string appSettingsKey, T defaultValue)
{
string text = ConfigurationManager.AppSettings[appSettingsKey];
if (string.IsNullOrWhiteSpace(text))
return defaultValue;
try
{
var value = Convert.ChangeType(text, typeof(T));
return (T)value;
}
catch
{
return defaultValue;
}
}
}下面是RedisClientConfigurationsprivate static string _url = ConfigurationHelper.Get("RedisServer", "127.0.0.1");
public static string Url
{
get { return _url; }
set { _url = value; }
}

private static int _port = 7000;
public static int Port
{
get { return _port; }
set { _port = value; }
}

private static int _connectTimeout = 10000;
public static int ConnectTimeout
{
get { return _connectTimeout; }
set { _connectTimeout = value; }
}

private static int _connectRetry = 3;
public static int ConnectRetry
{
get { return _connectRetry; }
set { _connectRetry = value; }
}

private static int _defaultDatabase = ConfigurationHelper.Get("RedisDataBase", 0);
public static int DefaultDatabase
{
get { return _defaultDatabase; }
set { _defaultDatabase = value; }
}

private static bool _preserveAsyncOrder = false;
public static bool PreserveAsyncOrder
{
get { return _preserveAsyncOrder; }
set { _preserveAsyncOrder = value; }
}
}RedisClient：static RedisClient()
{
ConfigurationOptions option = new ConfigurationOptions();
option.EndPoints.Add("127.0.0.1", 7005);
_redis = ConnectionMultiplexer.Connect(option);
_db = _redis.GetDatabase();
}

#region 私有公用方法   在其中我们序列化操作使用Newtonsoft.Json组件

private string SerializeContent(object value)
{
return JsonConvert.SerializeObject(value);
}

private T DeserializeContent<T>(RedisValue myString)
{
return JsonConvert.DeserializeObject<T>(myString);
}
/// <summary>
/// string类型存值并设置过期时间
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <param name="t"></param>
/// <param name="ts"></param>
/// <returns></returns>
public static bool Set<T>(string key, T t, TimeSpan ts)
{
var str = JsonConvert.SerializeObject(t);
return _db.StringSet(key, str,ts);
}

#endregion

string类型的封装

#region Redis String数据类型操作

/// <summary>
/// Redis String类型 新增一条记录
/// </summary>
/// <typeparam name="T">generic refrence type</typeparam>
/// <param name="key">unique key of value</param>
/// <param name="value">value of key of type T</param>
/// <param name="expiresAt">time span of expiration</param>
/// <returns>true or false</returns>
public bool StringSet<T>(string key, T value, TimeSpan? expiresAt = default(TimeSpan?), When when = When.Always, CommandFlags commandFlags = CommandFlags.None) where T : class
{
var stringContent = SerializeContent(value);
return _db.StringSet(key, stringContent, expiresAt, when, commandFlags);
}

/// <summary>
/// Redis String类型 新增一条记录
/// </summary>
/// <typeparam name="T">generic refrence type</typeparam>
/// <param name="key">unique key of value</param>
/// <param name="value">value of key of type object</param>
/// <param name="expiresAt">time span of expiration</param>
/// <returns>true or false</returns>
public bool StringSet<T>(string key, object value, TimeSpan? expiresAt = default(TimeSpan?), When when = When.Always, CommandFlags commandFlags = CommandFlags.None) where T : class
{
var stringContent = SerializeContent(value);

return _db.StringSet(key, stringContent, expiresAt, when, commandFlags);
}

/// <summary>
/// Redis String数据类型 获取指定key中字符串长度
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public long StringLength(string key, CommandFlags commandFlags = CommandFlags.None)
{
return _db.StringLength(key, commandFlags);
}

/// <summary>
///  Redis String数据类型  返回拼接后总长度
/// </summary>
/// <param name="key"></param>
/// <param name="appendVal"></param>
/// <returns>总长度</returns>
public long StringAppend(string key, string appendVal, CommandFlags commandFlags = CommandFlags.None)
{
return _db.StringAppend(key, appendVal, commandFlags);
}

/// <summary>
/// 设置新值并且返回旧值
/// </summary>
/// <param name="key"></param>
/// <param name="newVal"></param>
/// <param name="commandFlags"></param>
/// <returns>OldVal</returns>
public string StringGetAndSet(string key, string newVal, CommandFlags commandFlags = CommandFlags.None)
{
return DeserializeContent<string>(_db.StringGetSet(key, newVal, commandFlags));
}

/// <summary>
/// 更新时应使用此方法，代码更可读。
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <param name="value"></param>
/// <param name="expiresAt"></param>
/// <param name="when"></param>
/// <param name="commandFlags"></param>
/// <returns></returns>
public bool StringUpdate<T>(string key, T value, TimeSpan expiresAt, When when = When.Always, CommandFlags commandFlags = CommandFlags.None) where T : class
{
var stringContent = SerializeContent(value);
return _db.StringSet(key, stringContent, expiresAt, when, commandFlags);
}

/// <summary>
/// 为数字增长val
/// </summary>
/// <param name="key"></param>
/// <param name="val">可以为负</param>
/// <param name="commandFlags"></param>
/// <returns>增长后的值</returns>
public double StringIncrement(string key, double val, CommandFlags commandFlags = CommandFlags.None)
{
return _db.StringIncrement(key, val, commandFlags);
}

/// <summary>
/// Redis String类型  Get
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <returns>T</returns>
public T StringGet<T>(string key, CommandFlags commandFlags = CommandFlags.None) where T : class
{
try
{
RedisValue myString = _db.StringGet(key, commandFlags);
if (myString.HasValue && !myString.IsNullOrEmpty)
{
return DeserializeContent<T>(myString);
}
else
{
return null;
}
}
catch (Exception)
{
// Log Exception
return null;
}
}

/// <summary>
///  Redis String类型
/// 类似于模糊查询  key* 查出所有key开头的键
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <param name="pageSize"></param>
/// <param name="commandFlags"></param>
/// <returns>List<T></returns>
public List<T> StringGetList<T>(string key, int pageSize = 1000, CommandFlags commandFlags = CommandFlags.None) where T : class
{
try
{
var server = _redis.GetServer(host: RedisClientConfigurations.Url,
port: RedisClientConfigurations.Port);
var keys = server.Keys(_db.Database, key, pageSize, commandFlags);
var keyValues = _db.StringGet(keys.ToArray(), commandFlags);

var result = new List<T>();
foreach (var redisValue in keyValues)
{
if (redisValue.HasValue && !redisValue.IsNullOrEmpty)
{
var item = DeserializeContent<T>(redisValue);

ae20
result.Add(item);
}
}

return result;
}
catch (Exception)
{
// Log Exception
return null;
}
}

#endregion

hash类型的封装#region Redis Hash散列数据类型操作
/// <summary>
/// Redis散列数据类型 批量新增
/// </summary>
/// <param name="key"></param>
/// <param name="hashEntrys"></param>
/// <param name="flags"></param>
public void HashSet(string key, List<HashEntry> hashEntrys, CommandFlags flags = CommandFlags.None)
{
_db.HashSet(key, hashEntrys.ToArray(), flags);
}
/// <summary>
/// Redis散列数据类型 新增一个
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <param name="field"></param>
/// <param name="val"></param>
/// <param name="when"></param>
/// <param name="flags"></param>
public void HashSet<T>(string key, string field, T val, When when = When.Always, CommandFlags flags = CommandFlags.None)
{
_db.HashSet(key, field, SerializeContent(val), when, flags);
}
//public HashEntry[] HashScan(string key, string pattern, int pagesize, CommandFlags flags = CommandFlags.None)
//{
// return _db.HashScan(key, pattern, pagesize, flags);
//}

public async Task HashSetAsync<T>(string key, string field, T val, When when = When.Always, CommandFlags flags = CommandFlags.None)
{
await _db.HashSetAsync(key, field, SerializeContent(val), when, flags);
}
/// <summary>
/// Redis散列数据类型 获取指定key的指定field
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <param name="field"></param>
/// <returns></returns>
public T HashGet<T>(string key, string field)
{
return DeserializeContent<T>(_db.HashGet(key, field));
}
/// <summary>
/// Redis散列数据类型 获取所有field所有值,以 HashEntry[]形式返回
/// </summary>
/// <param name="key"></param>
/// <param name="flags"></param>
/// <returns></returns>
public HashEntry[] HashGetAll(string key, CommandFlags flags = CommandFlags.None)
{
return _db.HashGetAll(key, flags);
}
/// <summary>
/// 一个有问题的迭代器，可以便利hash key的全部元素
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <param name="pattern"></param>
/// <param name="pageSize"></param>
/// <returns></returns>
public List<T> HashScan<T>(string key,string pattern, int pageSize)
{
List<T> list = new List<T>();
var hashVals = _db.HashScan(key, pattern, pageSize).ToList();
foreach(var item in hashVals)
{
list.Add(DeserializeContent<T>(item.Value));
}
return list;
}
/// <summary>
/// Redis散列数据类型 获取key中所有field的值。
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <param name="flags"></param>
/// <returns></returns>
public List<T> HashGetAllValues<T>(string key, CommandFlags flags = CommandFlags.None)
{
List<T> list = new List<T>();
var hashVals = _db.HashValues(key, flags).ToList();
foreach (var item in hashVals)
{
list.Add(DeserializeContent<T>(item));
}
return list;
}

public void HashScan(string key,string pattern,int pagesize)
{
_db.HashScan(key, pattern, pagesize);
}

public async Task<List<T>> HashGetAllValuseAsync<T>(string key, CommandFlags flags = CommandFlags.None)
{
List<T> list = new List<T>();
var hashVals = await _db.HashValuesAsync(key, flags);
foreach(var item in hashVals)
{
list.Add(DeserializeContent<T>(item));
}
return list;
}
/// <summary>
/// Redis散列数据类型 获取所有Key名称
/// </summary>
/// <param name="key"></param>
/// <param name="flags"></param>
/// <returns></returns>
public string[] HashGetAllKeys(string key, CommandFlags flags = CommandFlags.None)
{
return _db.HashKeys(key, flags).ToStringArray();
}
/// <summary>
/// Redis散列数据类型 单个删除field
/// </summary>
/// <param name="key"></param>
/// <param name="hashField"></param>
/// <param name="flags"></param>
/// <returns></returns>
public bool HashDelete(string key, string hashField, CommandFlags flags = CommandFlags.None)
{
return _db.HashDelete(key, hashField, flags);
}
/// <summary>
/// Redis散列数据类型 批量删除field
/// </summary>
/// <param name="key"></param>
/// <param name="hashFields"></param>
/// <param name="flags"></param>
/// <returns></returns>
public long HashDelete(string key, string[] hashFields, CommandFlags flags = CommandFlags.None)
{
List<RedisValue> list = new List<RedisValue>();
for (int i = 0; i < hashFields.Length; i++)
{
list.Add(hashFields[i]);
}
return _db.HashDelete(key, list.ToArray(), flags);
}
/// <summary>
/// Redis散列数据类型 判断指定键中是否存在此field
/// </summary>
/// <param name="key"></param>
/// <param name="field"></param>
/// <param name="flags"></param>
/// <returns></returns>
public bool HashExists(string key, string field, CommandFlags flags = CommandFlags.None)
{
return _db.HashExists(key, field, flags);
}
/// <summary>
/// Redis散列数据类型 获取指定key中field数量
/// </summary>
/// <param name="key"></param>
/// <param name="flags"></param>
/// <returns></returns>
public long HashLength(string key, CommandFlags flags = CommandFlags.None)
{
return _db.HashLength(key, flags);
}
/// <summary>
/// Redis散列数据类型 为key中指定field增加incrVal值
/// </summary>
/// <param name="key"></param>
/// <param name="field"></param>
/// <param name="incrVal"></param>
/// <param name="flags"></param>
/// <returns></returns>
public double HashIncrement(string key, string field, double incrVal, CommandFlags flags = CommandFlags.None)
{
return _db.HashIncrement(key, field, incrVal, flags);
}

#endregionhash类型中可以使用scan这个迭代器对hash类型进行模糊查询，效率很高。有兴趣可以对我使用。
这是我主要使用的两个类型，其他类型暂时没用到=-=，也没有收集，不过网上会有很多。