一、Signalr WebApi客服-客户链接+Redis
2024-10-21 06:30:37
一、前端客服代码
<!doctype html>
<html>
<head>
<meta charset="utf-8">
<title>LayIM测试</title>
<link rel="stylesheet" href="./layui/css/layui.css" media="all">
<link rel="stylesheet" href="./contextMenu/contextMenu.css">
</head>
<body>
<script src="./layui/layui.js"></script>
<script>
layui.config({
base: './contextMenu/' //扩展 JS 所在目录
,version: true
}).extend({
ext: 'contextMenu'
});
//演示代码
layui.use('layim', function(layim){
var layim = layui.layim;
layim.config({
init: {
//配置客户信息
mine: {
"username": "访客" //我的昵称
,"id": "100000123" //我的ID
,"status": "online" //在线状态 online：在线、hide：隐身
,"remark": "在深邃的编码世界，做一枚轻盈的纸飞机" //我的签名
,"avatar": "//res.layui.com/images/fly/avatar/00.jpg" //我的头像
}
}
//开启客服模式
,brief: true
});
//打开一个客服面板
layim.chat({
name: '在线客服一' //名称
,type: 'kefu' //聊天类型
,avatar: '//tp1.sinaimg.cn/5619439268/180/40030060651/1' //头像
,id: 1111111 //定义唯一的id方便你处理信息
}).chat({
name: '在线客服二' //名称
,type: 'kefu' //聊天类型
,avatar: '//tp1.sinaimg.cn/5619439268/180/40030060651/1' //头像
,id: 2222222 //定义唯一的id方便你处理信息
});
layim.setChatMin(); //收缩聊天面板
});
</script>
</body>
</html>
二、在.Net Core 2.1中使用
1、安装依赖包：Nugget: StackExchange.Redis
2、新建Helper类库，并添加RedisHelper.cs类
public class RedisHelper
{
private ConnectionMultiplexer Redis { get; set; }
private IDatabase DB { get; set; }
public RedisHelper(string connection)
{
Redis = ConnectionMultiplexer.Connect(connection);
DB = Redis.GetDatabase();
} /// <summary>
/// 增加/修改
/// </summary>
/// <param name="key"></param>
/// <param name="value"></param>
/// <returns></returns>
public bool SetValue(string key, string value)
{
return DB.StringSet(key, value);
} /// <summary>
/// 查询
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public string GetValue(string key)
{
return DB.StringGet(key);
} /// <summary>
/// 删除
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public bool DeleteKey(string key)
{
return DB.KeyDelete(key);
}
}
3、使用
RedisHelper redisHelper = new RedisHelper("127.0.0.1:6379");
string value = "测试数据";
bool testValue = redisHelper.SetValue("key", value);
string saveValue = redisHelper.GetValue("key");
Console.WriteLine(saveValue);
bool newValue = redisHelper.SetValue("key", "NewValue");
saveValue = redisHelper.GetValue("key");
Console.WriteLine(saveValue);
bool deleteKey = redisHelper.DeleteKey("key");
string empty = redisHelper.GetValue("key");
Console.WriteLine(empty);
Console.ReadKey();
高级玩法： https://www.cnblogs.com/kellynic/p/9803314.html
3、Redis封装
1、RedisHelper
using Newtonsoft.Json;
using StackExchange.Redis;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks; namespace RedisClientService
{
/// <summary>
/// Redis操作
/// </summary>
public class RedisHelper
{
private int DbNum { get; set; }
private readonly ConnectionMultiplexer _conn;
public string CustomKey; #region 构造函数 public RedisHelper(int dbNum = )
: this(dbNum, null)
{
} public RedisHelper(int dbNum, string readWriteHosts)
{
DbNum = dbNum;
_conn =
string.IsNullOrWhiteSpace(readWriteHosts) ?
RedisConnectionHelp.Instance :
RedisConnectionHelp.GetConnectionMultiplexer(readWriteHosts);
} #endregion #region String #region 同步方法 /// <summary>
/// 保存单个key value
/// </summary>
/// <param name="key">Redis Key</param>
/// <param name="value">保存的值</param>
/// <param name="expiry">过期时间</param>
/// <returns></returns>
public bool StringSet(string key, string value, TimeSpan? expiry = default(TimeSpan?))
{
key = AddSysCustomKey(key);
return Do(db => db.StringSet(key, value, expiry));
} /// <summary>
/// 保存多个key value
/// </summary>
/// <param name="keyValues">键值对</param>
/// <returns></returns>
public bool StringSet(List<KeyValuePair<RedisKey, RedisValue>> keyValues)
{
List<KeyValuePair<RedisKey, RedisValue>> newkeyValues =
keyValues.Select(p => new KeyValuePair<RedisKey, RedisValue>(AddSysCustomKey(p.Key), p.Value)).ToList();
return Do(db => db.StringSet(newkeyValues.ToArray())); } /// <summary>
/// 保存一个对象
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <param name="obj"></param>
/// <param name="expiry"></param>
/// <returns></returns>
public bool StringSet<T>(string key, T obj, TimeSpan? expiry = default(TimeSpan?))
{
key = AddSysCustomKey(key);
string json = ConvertJson(obj);
return Do(db => db.StringSet(key, json, expiry));
} /// <summary>
/// 获取单个key的值
/// </summary>
/// <param name="key">Redis Key</param>
/// <returns></returns>
public string StringGet(string key)
{
key = AddSysCustomKey(key);
return Do(db => db.StringGet(key));
} /// <summary>
/// 获取多个Key
/// </summary>
/// <param name="listKey">Redis Key集合</param>
/// <returns></returns>
public RedisValue[] StringGet(List<string> listKey)
{
List<string> newKeys = listKey.Select(AddSysCustomKey).ToList();
return Do(db => db.StringGet(ConvertRedisKeys(newKeys)));
} /// <summary>
/// 获取一个key的对象
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <returns></returns>
public T StringGet<T>(string key)
{
key = AddSysCustomKey(key);
return Do(db => ConvertObj<T>(db.StringGet(key)));
} /// <summary>
/// 为数字增长val
/// </summary>
/// <param name="key"></param>
/// <param name="val">可以为负</param>
/// <returns>增长后的值</returns>
public double StringIncrement(string key, double val = )
{
key = AddSysCustomKey(key);
return Do(db => db.StringIncrement(key, val));
} /// <summary>
/// 为数字减少val
/// </summary>
/// <param name="key"></param>
/// <param name="val">可以为负</param>
/// <returns>减少后的值</returns>
public double StringDecrement(string key, double val = )
{
key = AddSysCustomKey(key);
return Do(db => db.StringDecrement(key, val));
} #endregion 同步方法 #region 异步方法 /// <summary>
/// 保存单个key value
/// </summary>
/// <param name="key">Redis Key</param>
/// <param name="value">保存的值</param>
/// <param name="expiry">过期时间</param>
/// <returns></returns>
public async Task<bool> StringSetAsync(string key, string value, TimeSpan? expiry = default(TimeSpan?))
{
key = AddSysCustomKey(key);
return await Do(db => db.StringSetAsync(key, value, expiry));
} /// <summary>
/// 保存多个key value
/// </summary>
/// <param name="keyValues">键值对</param>
/// <returns></returns>
public async Task<bool> StringSetAsync(List<KeyValuePair<RedisKey, RedisValue>> keyValues)
{
List<KeyValuePair<RedisKey, RedisValue>> newkeyValues =
keyValues.Select(p => new KeyValuePair<RedisKey, RedisValue>(AddSysCustomKey(p.Key), p.Value)).ToList();
return await Do(db => db.StringSetAsync(newkeyValues.ToArray()));
} /// <summary>
/// 保存一个对象
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <param name="obj"></param>
/// <param name="expiry"></param>
/// <returns></returns>
public async Task<bool> StringSetAsync<T>(string key, T obj, TimeSpan? expiry = default(TimeSpan?))
{
key = AddSysCustomKey(key);
string json = ConvertJson(obj);
return await Do(db => db.StringSetAsync(key, json, expiry));
} /// <summary>
/// 获取单个key的值
/// </summary>
/// <param name="key">Redis Key</param>
/// <returns></returns>
public async Task<string> StringGetAsync(string key)
{
key = AddSysCustomKey(key);
return await Do(db => db.StringGetAsync(key));
} /// <summary>
/// 获取多个Key
/// </summary>
/// <param name="listKey">Redis Key集合</param>
/// <returns></returns>
public async Task<RedisValue[]> StringGetAsync(List<string> listKey)
{
List<string> newKeys = listKey.Select(AddSysCustomKey).ToList();
return await Do(db => db.StringGetAsync(ConvertRedisKeys(newKeys)));
} /// <summary>
/// 获取一个key的对象
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <returns></returns>
public async Task<T> StringGetAsync<T>(string key)
{
key = AddSysCustomKey(key);
string result = await Do(db => db.StringGetAsync(key));
return ConvertObj<T>(result);
} /// <summary>
/// 为数字增长val
/// </summary>
/// <param name="key"></param>
/// <param name="val">可以为负</param>
/// <returns>增长后的值</returns>
public async Task<double> StringIncrementAsync(string key, double val = )
{
key = AddSysCustomKey(key);
return await Do(db => db.StringIncrementAsync(key, val));
} /// <summary>
/// 为数字减少val
/// </summary>
/// <param name="key"></param>
/// <param name="val">可以为负</param>
/// <returns>减少后的值</returns>
public async Task<double> StringDecrementAsync(string key, double val = )
{
key = AddSysCustomKey(key);
return await Do(db => db.StringDecrementAsync(key, val));
} #endregion 异步方法 #endregion #region Hash #region 同步方法 /// <summary>
/// 判断某个数据是否已经被缓存
/// </summary>
/// <param name="key"></param>
/// <param name="dataKey"></param>
/// <returns></returns>
public bool HashExists(string key, string dataKey)
{
key = AddSysCustomKey(key);
return Do(db => db.HashExists(key, dataKey));
} /// <summary>
/// 存储数据到hash表
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <param name="dataKey"></param>
/// <param name="t"></param>
/// <returns></returns>
public bool HashSet<T>(string key, string dataKey, T t)
{
key = AddSysCustomKey(key);
return Do(db =>
{
string json = ConvertJson(t);
return db.HashSet(key, dataKey, json);
});
} /// <summary>
/// 移除hash中的某值
/// </summary>
/// <param name="key"></param>
/// <param name="dataKey"></param>
/// <returns></returns>
public bool HashDelete(string key, string dataKey)
{
key = AddSysCustomKey(key);
return Do(db => db.HashDelete(key, dataKey));
} /// <summary>
/// 移除hash中的多个值
/// </summary>
/// <param name="key"></param>
/// <param name="dataKeys"></param>
/// <returns></returns>
public long HashDelete(string key, List<RedisValue> dataKeys)
{
key = AddSysCustomKey(key);
//List<RedisValue> dataKeys1 = new List<RedisValue>() {"1","2"};
return Do(db => db.HashDelete(key, dataKeys.ToArray()));
} /// <summary>
/// 获取hash值列表,返回HashEntry[]
/// </summary>
/// <typeparam name="T">HashEntry[]</typeparam>
/// <param name="key"></param>
/// <returns></returns>
public HashEntry[] HashGetAll(string key)
{
key = AddSysCustomKey(key);
return Do(db =>
{
var value = db.HashGetAll(key);
return value;
});
} /// <summary>
/// 获取hash值列表,返回 List<T>,不带条件查询
/// </summary>
/// <typeparam name="T">List<T></typeparam>
/// <param name="key"></param>
/// <returns></returns>
public IList<T> HashGetAll<T>(string key)
{
key = AddSysCustomKey(key);
return Do(db =>
{
var values = db.HashGetAll(key).Select(m => m.Value);
return ConvetList<T>(values);
});
} /// <summary>
/// 获取hash值列表,返回 List<T>,不带条件查询
/// </summary>
/// <typeparam name="T">List<T></typeparam>
/// <param name="key"></param>
/// <returns></returns>
public IEnumerable<T> HashGetEnumerableAll<T>(string key)
{
key = AddSysCustomKey(key);
return Do(db =>
{
var values = db.HashGetAll(key).Select(m => m.Value);
return ConvetEnumerable<T>(values);
});
} /// <summary>
/// 获取hash值列表,返回 List<T>,不带条件查询
/// </summary>
/// <typeparam name="T">List<T></typeparam>
/// <param name="key"></param>
/// <returns></returns>
public IEnumerable<T> HashValuesAsync<T>(string key)
{
key = AddSysCustomKey(key);
return Do(db =>
{
var values = db.HashValuesAsync(key).Result;
return ConvetEnumerable<T>(values);
});
} ///// <summary>
///// 获取hash值列表,返回 List<T>
///// </summary>
///// <typeparam name="T"></typeparam>
///// <param name="key"></param>
///// <param name="strwhere"></param>
///// <returns></returns>
//public List<T> HashGetAll<T>(string key, string strwhere)
//{
// key = AddSysCustomKey(key);
// var db = _conn.GetDatabase(DbNum);
// var values = db.HashGetAll(key);
// if (values != null && values.Length > 0 && !string.IsNullOrWhiteSpace(strwhere))
// { // }
//} /// <summary>
/// 从hash表获取数据
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <param name="dataKey"></param>
/// <returns></returns>
public T HashGet<T>(string key, string dataKey)
{
key = AddSysCustomKey(key);
return Do(db =>
{
string value = db.HashGet(key, dataKey);
return ConvertObj<T>(value);
});
} /// <summary>
/// 为数字增长val
/// </summary>
/// <param name="key"></param>
/// <param name="dataKey"></param>
/// <param name="val">可以为负</param>
/// <returns>增长后的值</returns>
public double HashIncrement(string key, string dataKey, double val = )
{
key = AddSysCustomKey(key);
return Do(db => db.HashIncrement(key, dataKey, val));
} /// <summary>
/// 为数字减少val
/// </summary>
/// <param name="key"></param>
/// <param name="dataKey"></param>
/// <param name="val">可以为负</param>
/// <returns>减少后的值</returns>
public double HashDecrement(string key, string dataKey, double val = )
{
key = AddSysCustomKey(key);
return Do(db => db.HashDecrement(key, dataKey, val));
} /// <summary>
/// 获取hashkey所有Redis key
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <returns></returns>
public List<T> HashKeys<T>(string key)
{
key = AddSysCustomKey(key);
return Do(db =>
{
RedisValue[] values = db.HashKeys(key);
return ConvetList<T>(values);
});
} #endregion 同步方法 #region 异步方法 /// <summary>
/// 判断某个数据是否已经被缓存
/// </summary>
/// <param name="key"></param>
/// <param name="dataKey"></param>
/// <returns></returns>
public async Task<bool> HashExistsAsync(string key, string dataKey)
{
key = AddSysCustomKey(key);
return await Do(db => db.HashExistsAsync(key, dataKey));
} /// <summary>
/// 存储数据到hash表
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <param name="dataKey"></param>
/// <param name="t"></param>
/// <returns></returns>
public async Task<bool> HashSetAsync<T>(string key, string dataKey, T t)
{
key = AddSysCustomKey(key);
return await Do(db =>
{
string json = ConvertJson(t);
return db.HashSetAsync(key, dataKey, json);
});
} /// <summary>
/// 移除hash中的某值
/// </summary>
/// <param name="key"></param>
/// <param name="dataKey"></param>
/// <returns></returns>
public async Task<bool> HashDeleteAsync(string key, string dataKey)
{
key = AddSysCustomKey(key);
return await Do(db => db.HashDeleteAsync(key, dataKey));
} /// <summary>
/// 移除hash中的多个值
/// </summary>
/// <param name="key"></param>
/// <param name="dataKeys"></param>
/// <returns></returns>
public async Task<long> HashDeleteAsync(string key, List<RedisValue> dataKeys)
{
key = AddSysCustomKey(key);
//List<RedisValue> dataKeys1 = new List<RedisValue>() {"1","2"};
return await Do(db => db.HashDeleteAsync(key, dataKeys.ToArray()));
} /// <summary>
/// 从hash表获取数据
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <param name="dataKey"></param>
/// <returns></returns>
public async Task<T> HashGeAsync<T>(string key, string dataKey)
{
key = AddSysCustomKey(key);
string value = await Do(db => db.HashGetAsync(key, dataKey));
return ConvertObj<T>(value);
} /// <summary>
/// 为数字增长val
/// </summary>
/// <param name="key"></param>
/// <param name="dataKey"></param>
/// <param name="val">可以为负</param>
/// <returns>增长后的值</returns>
public async Task<double> HashIncrementAsync(string key, string dataKey, double val = )
{
key = AddSysCustomKey(key);
return await Do(db => db.HashIncrementAsync(key, dataKey, val));
} /// <summary>
/// 为数字减少val
/// </summary>
/// <param name="key"></param>
/// <param name="dataKey"></param>
/// <param name="val">可以为负</param>
/// <returns>减少后的值</returns>
public async Task<double> HashDecrementAsync(string key, string dataKey, double val = )
{
key = AddSysCustomKey(key);
return await Do(db => db.HashDecrementAsync(key, dataKey, val));
} /// <summary>
/// 获取hashkey所有Redis key
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <returns></returns>
public async Task<List<T>> HashKeysAsync<T>(string key)
{
key = AddSysCustomKey(key);
RedisValue[] values = await Do(db => db.HashKeysAsync(key));
return ConvetList<T>(values);
} #endregion 异步方法 #endregion #region List #region 同步方法 /// <summary>
/// 移除指定ListId的内部List的值
/// </summary>
/// <param name="key"></param>
/// <param name="value"></param>
public void ListRemove<T>(string key, T value)
{
key = AddSysCustomKey(key);
Do(db => db.ListRemove(key, ConvertJson(value)));
} /// <summary>
/// 获取指定key的List
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public List<T> ListRange<T>(string key)
{
key = AddSysCustomKey(key);
return Do(redis =>
{
var values = redis.ListRange(key);
return ConvetList<T>(values);
});
} /// <summary>
/// 返回list的数目
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public int ListRangeCount(string key)
{
key = AddSysCustomKey(key);
return Do(redis =>
{
return redis.ListRange(key).Length;
});
} /// <summary>
/// 入队
/// </summary>
/// <param name="key"></param>
/// <param name="value"></param>
public void ListRightPush<T>(string key, T value)
{
key = AddSysCustomKey(key);
Do(db => db.ListRightPush(key, ConvertJson(value)));
} /// <summary>
/// List string类型入队
/// </summary>
/// <param name="key"></param>
/// <param name="value"></param>
public void ListRightStringPush(string key, string value)
{
key = AddSysCustomKey(key);
Do(db => db.ListRightPush(key, value));
} /// <summary>
/// 出队
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <returns></returns>
public T ListRightPop<T>(string key)
{
key = AddSysCustomKey(key);
return Do(db =>
{
var value = db.ListRightPop(key);
return ConvertObj<T>(value);
});
} /// <summary>
/// List string类型出队
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public string ListRightStringPop(string key)
{
key = AddSysCustomKey(key);
return Do(db =>
{
var value = db.ListRightPop(key);
return value.ToString();
});
} /// <summary>
/// 入栈
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <param name="value"></param>
public void ListLeftPush<T>(string key, T value)
{
key = AddSysCustomKey(key);
Do(db => db.ListLeftPush(key, ConvertJson(value)));
} /// <summary>
/// 出栈
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <returns></returns>
public T ListLeftPop<T>(string key)
{
key = AddSysCustomKey(key);
return Do(db =>
{
var value = db.ListLeftPop(key);
return ConvertObj<T>(value);
});
} /// <summary>
/// 获取集合中的数量
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public long ListLength(string key)
{
key = AddSysCustomKey(key);
return Do(redis => redis.ListLength(key));
} #endregion 同步方法 #region 异步方法 /// <summary>
/// 移除指定ListId的内部List的值
/// </summary>
/// <param name="key"></param>
/// <param name="value"></param>
public async Task<long> ListRemoveAsync<T>(string key, T value)
{
key = AddSysCustomKey(key);
return await Do(db => db.ListRemoveAsync(key, ConvertJson(value)));
} /// <summary>
/// 获取指定key的List
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public async Task<List<T>> ListRangeAsync<T>(string key)
{
key = AddSysCustomKey(key);
var values = await Do(redis => redis.ListRangeAsync(key));
return ConvetList<T>(values);
} /// <summary>
/// 入队
/// </summary>
/// <param name="key"></param>
/// <param name="value"></param>
public async Task<long> ListRightPushAsync<T>(string key, T value)
{
key = AddSysCustomKey(key);
return await Do(db => db.ListRightPushAsync(key, ConvertJson(value)));
} /// <summary>
/// 出队
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <returns></returns>
public async Task<T> ListRightPopAsync<T>(string key)
{
key = AddSysCustomKey(key);
var value = await Do(db => db.ListRightPopAsync(key));
return ConvertObj<T>(value);
} /// <summary>
/// 入栈
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <param name="value"></param>
public async Task<long> ListLeftPushAsync<T>(string key, T value)
{
key = AddSysCustomKey(key);
return await Do(db => db.ListLeftPushAsync(key, ConvertJson(value)));
} /// <summary>
/// 出栈
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <returns></returns>
public async Task<T> ListLeftPopAsync<T>(string key)
{
key = AddSysCustomKey(key);
var value = await Do(db => db.ListLeftPopAsync(key));
return ConvertObj<T>(value);
} /// <summary>
/// 获取集合中的数量
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public async Task<long> ListLengthAsync(string key)
{
key = AddSysCustomKey(key);
return await Do(redis => redis.ListLengthAsync(key));
} #endregion 异步方法 #endregion #region Set /// <summary>
/// 返回set总条数
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <returns></returns>
public long SetLength<T>(string key)
{
key = AddSysCustomKey(key);
return Do(redis => redis.SetLength(key));
} /// <summary>
/// 添加Set
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <param name="t"></param>
/// <returns></returns>
public bool SetAdd<T>(string key, T value)
{
key = AddSysCustomKey(key);
return Do(redis => redis.SetAdd(key, ConvertJson<T>(value)));
} /// <summary>
/// 删除Set
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <param name="t"></param>
/// <returns></returns>
public bool SetRemove<T>(string key, T value)
{
key = AddSysCustomKey(key);
return Do(redis => redis.SetRemove(key, ConvertJson<T>(value)));
} /// <summary>
/// 获取全部
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public List<T> SetMembers<T>(string key)
{
key = AddSysCustomKey(key);
return Do(redis =>
{
var values = redis.SetMembers(key);
return ConvetList<T>(values);
});
} #region Set分页
/// <summary>
/// Set分页
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <param name="pattern"></param>
/// <param name="pageSize"></param>
/// <param name="cursor"></param>
/// <param name="pageOffset"></param>
/// <param name="flags"></param>
/// <returns></returns>
public List<T> SetScan<T>(RedisKey key, string pattern = "", int pageSize = , long cursor = , int pageOffset = , CommandFlags flags = CommandFlags.None)
{
key = AddSysCustomKey(key);
var values = _conn.GetDatabase(DbNum).SetScan(key, pattern, pageSize, cursor, pageOffset, flags).ToArray();
return ConvetList<T>(values);
}
#endregion /// <summary>
/// 批量插入Set
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="t"></param>
/// <param name="key"></param>
/// <returns></returns>
public void SetBatchAdd<T>(IEnumerable<T> t, string key)
{
if (t != null && t.Count() > )
{
var Batch = _conn.GetDatabase(DbNum).CreateBatch();
var list = t.Select(item =>
{
return (RedisValue)JsonConvert.SerializeObject(item);
});
Batch.SetAddAsync(key, list.ToArray(), CommandFlags.None);
Batch.Execute();
}
} #endregion #region SortedSet 有序集合 #region 同步方法 /// <summary>
/// 添加
/// </summary>
/// <param name="key"></param>
/// <param name="value"></param>
/// <param name="score"></param>
public bool SortedSetAdd<T>(string key, T value, double score)
{
key = AddSysCustomKey(key);
return Do(redis => redis.SortedSetAdd(key, ConvertJson<T>(value), score));
} public long SortedSetAdd(string key, SortedSetEntry[] value)
{
return Do(redis => redis.SortedSetAdd(key, value));
} /// <summary>
/// 批量插入SortedSet
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="t"></param>
/// <param name="key">redis键</param>
/// <param name="scorePropertyName">score属性名称</param>
public void SortedSetBatchAdd<T>(IEnumerable<T> t, string key, string scorePropertyName)
{
double i = 1d;
if (t != null && t.Count() > )
{
var Batch = _conn.GetDatabase(DbNum).CreateBatch();
var list = t.Select(item =>
{
double score = !string.IsNullOrWhiteSpace(scorePropertyName) ? double.Parse(GetObjectPropertyValue<T>(item, scorePropertyName).ToString()) : (i++);
return new SortedSetEntry(JsonConvert.SerializeObject(item), score);
});
Batch.SortedSetAddAsync(key, list.ToArray(), CommandFlags.None);
Batch.Execute();
}
} /// <summary>
/// 删除
/// </summary>
/// <param name="key"></param>
/// <param name="value"></param>
public bool SortedSetRemove<T>(string key, T value)
{
key = AddSysCustomKey(key);
return Do(redis => redis.SortedSetRemove(key, ConvertJson(value)));
} /// <summary>
/// 获取全部
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public List<T> SortedSetRangeByRank<T>(string key)
{
key = AddSysCustomKey(key);
return Do(redis =>
{
var values = redis.SortedSetRangeByRank(key);
return ConvetList<T>(values);
});
} /// <summary>
/// 获取条件指定的数据-分页
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <param name="start"></param>
/// <param name="stop"></param>
/// <returns></returns>
public List<T> SortedSetRangeByRankPage<T>(string key, long start = , long stop = -, int order = , int cmdFlags = )
{
key = AddSysCustomKey(key);
return Do(redis =>
{
var values = redis.SortedSetRangeByRank(key, start, stop, order == ? Order.Ascending : Order.Descending, (CommandFlags)cmdFlags);
return ConvetList<T>(values);
});
} /// <summary>
/// 获取集合中的数量
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public long SortedSetLength(string key)
{
key = AddSysCustomKey(key);
return Do(redis => redis.SortedSetLength(key));
}
#endregion #region 异步方法
/// <summary>
/// 添加
/// </summary>
/// <param name="key"></param>
/// <param name="value"></param>
/// <param name="score"></param>
public async Task<bool> SortedSetAddAsync<T>(string key, T value, double score)
{
key = AddSysCustomKey(key);
return await Do(redis => redis.SortedSetAddAsync(key, ConvertJson<T>(value), score));
} /// <summary>
/// 删除
/// </summary>
/// <param name="key"></param>
/// <param name="value"></param>
public async Task<bool> SortedSetRemoveAsync<T>(string key, T value)
{
key = AddSysCustomKey(key);
return await Do(redis => redis.SortedSetRemoveAsync(key, ConvertJson(value)));
} /// <summary>
/// 获取全部
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public async Task<List<T>> SortedSetRangeByRankAsync<T>(string key)
{
key = AddSysCustomKey(key);
var values = await Do(redis => redis.SortedSetRangeByRankAsync(key));
return ConvetList<T>(values);
} /// <summary>
/// 获取集合中的数量
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public async Task<long> SortedSetLengthAsync(string key)
{
key = AddSysCustomKey(key);
return await Do(redis => redis.SortedSetLengthAsync(key));
} #endregion #endregion #region key /// <summary>
/// 删除单个key
/// </summary>
/// <param name="key">redis key</param>
/// <returns>是否删除成功</returns>
public bool KeyDelete(string key)
{
key = AddSysCustomKey(key);
return Do(db => db.KeyDelete(key));
} /// <summary>
/// 删除多个key
/// </summary>
/// <param name="keys">rediskey</param>
/// <returns>成功删除的个数</returns>
public long KeyDelete(List<string> keys)
{
List<string> newKeys = keys.Select(AddSysCustomKey).ToList();
return Do(db => db.KeyDelete(ConvertRedisKeys(newKeys)));
} /// <summary>
/// 判断key是否存储
/// </summary>
/// <param name="key">redis key</param>
/// <returns></returns>
public bool KeyExists(string key)
{
key = AddSysCustomKey(key);
return Do(db => db.KeyExists(key));
} /// <summary>
/// 重新命名key
/// </summary>
/// <param name="key">就的redis key</param>
/// <param name="newKey">新的redis key</param>
/// <returns></returns>
public bool KeyRename(string key, string newKey)
{
key = AddSysCustomKey(key);
return Do(db => db.KeyRename(key, newKey));
} /// <summary>
/// 设置Key的时间
/// </summary>
/// <param name="key">redis key</param>
/// <param name="expiry"></param>
/// <returns></returns>
public bool KeyExpire(string key, TimeSpan? expiry = default(TimeSpan?))
{
key = AddSysCustomKey(key);
return Do(db => db.KeyExpire(key, expiry));
} #endregion #region 队列
//public bool EnqueueItemOnList(string key)
//{
// //key = AddSysCustomKey(key);
// //return Do(db => db.en);
// // return Do(db => db.list); //}
//public bool KeyDelete(string key)
//{
// key = AddSysCustomKey(key);
// return Do(db => db.KeyDelete(key));
//}
#endregion #region 发布订阅 /// <summary>
/// Redis发布订阅 订阅
/// </summary>
/// <param name="subChannel"></param>
/// <param name="handler"></param>
public void Subscribe(string subChannel, Action<RedisChannel, RedisValue> handler = null)
{
ISubscriber sub = _conn.GetSubscriber();
sub.Subscribe(subChannel, (channel, message) =>
{
if (handler == null)
{
Console.WriteLine(subChannel + " 订阅收到消息：" + message);
}
else
{
handler(channel, message);
}
});
} /// <summary>
/// Redis发布订阅 发布
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="channel"></param>
/// <param name="msg"></param>
/// <returns></returns>
public long Publish<T>(string channel, T msg)
{
ISubscriber sub = _conn.GetSubscriber();
return sub.Publish(channel, ConvertJson(msg));
} /// <summary>
/// Redis发布订阅 取消订阅
/// </summary>
/// <param name="channel"></param>
public void Unsubscribe(string channel)
{
ISubscriber sub = _conn.GetSubscriber();
sub.Unsubscribe(channel);
} /// <summary>
/// Redis发布订阅 取消全部订阅
/// </summary>
public void UnsubscribeAll()
{
ISubscriber sub = _conn.GetSubscriber();
sub.UnsubscribeAll();
} #endregion #region 其他 public ITransaction CreateTransaction()
{
return GetDatabase().CreateTransaction();
} public IDatabase GetDatabase()
{
return _conn.GetDatabase(DbNum);
} public IServer GetServer(string hostAndPort)
{
return _conn.GetServer(hostAndPort);
} /// <summary>
/// 设置前缀
/// </summary>
/// <param name="customKey"></param>
public void SetSysCustomKey(string customKey)
{
CustomKey = customKey;
} #endregion #region 辅助方法 private string AddSysCustomKey(string oldKey)
{
var prefixKey = CustomKey ?? RedisConnectionHelp.SysCustomKey;
return prefixKey + oldKey;
} private T Do<T>(Func<IDatabase, T> func)
{
var database = _conn.GetDatabase(DbNum);
return func(database);
} private string ConvertJson<T>(T value)
{
string result = value is string ? value.ToString() : JsonConvert.SerializeObject(value);
return result;
} private T ConvertObj<T>(RedisValue value)
{
return JsonConvert.DeserializeObject<T>(value);
} private List<T> ConvetList<T>(RedisValue[] values)
{
List<T> result = new List<T>();
foreach (var item in values)
{
var model = ConvertObj<T>(item);
result.Add(model);
}
return result;
} private List<T> ConvetList<T>(IEnumerable<RedisValue> values)
{
List<T> result = new List<T>();
foreach (var item in values)
{
var model = ConvertObj<T>(item);
result.Add(model);
}
return result;
} private IEnumerable<T> ConvetEnumerable<T>(IEnumerable<RedisValue> values)
{
IList<T> result = new List<T>();
foreach (var item in values)
{
var model = ConvertObj<T>(item);
result.Add(model);
}
return result;
} private RedisKey[] ConvertRedisKeys(List<string> redisKeys)
{
return redisKeys.Select(redisKey => (RedisKey)redisKey).ToArray();
} /// <summary>
/// 反射实体的值
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="t"></param>
/// <param name="propertyname"></param>
/// <returns></returns>
private string GetObjectPropertyValue<T>(T t, string propertyname)
{
Type type = typeof(T);
PropertyInfo property = type.GetProperty(propertyname);
if (property == null) return string.Empty;
object o = property.GetValue(t, null);
if (o == null) return string.Empty;
return o.ToString();
}
#endregion
}
}
2、RedisConnectionHelp
using Global;
using StackExchange.Redis;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Configuration;
using System.Linq;
using System.Text;
using System.Threading.Tasks; namespace RedisClientService
{
/// <summary>
/// ConnectionMultiplexer对象管理帮助类
/// </summary>
public static class RedisConnectionHelp
{
//系统自定义Key前缀
public static string SysCustomKey = ConfigurationManager.AppSettings["redisKey"] ?? "";
private static readonly object Locker = new object();
private static ConnectionMultiplexer _instance;
private static readonly ConcurrentDictionary<string, ConnectionMultiplexer> ConnectionCache = new ConcurrentDictionary<string, ConnectionMultiplexer>(); #region 单例获取
/// <summary>
/// 单例获取
/// </summary>
public static ConnectionMultiplexer Instance
{
get
{
if (_instance == null)
{
lock (Locker)
{
if (_instance == null || !_instance.IsConnected)
{
_instance = GetManager();
}
}
}
return _instance;
}
}
#endregion #region 缓存获取
/// <summary>
/// 缓存获取
/// </summary>
/// <param name="connectionString"></param>
/// <returns></returns>
public static ConnectionMultiplexer GetConnectionMultiplexer(string connectionString)
{
if (!ConnectionCache.ContainsKey(connectionString))
{
ConnectionCache[connectionString] = GetManager(connectionString);
}
return ConnectionCache[connectionString]; // return GetManager(connectionString);
} /// <summary>
/// 获取管理器
/// </summary>
/// <param name="connectionString"></param>
/// <returns></returns>
private static ConnectionMultiplexer GetManager(string connectionString = null)
{
// connectionString = connectionString ?? ReadRedisConnectionString;
connectionString = connectionString ?? RedisGlobals.ReadAndWriteRedisConnectionString; //ConfigurationOptions options = ConfigurationOptions.Parse(connectionString);
//options.ConnectTimeout = 1000;
var connect = ConnectionMultiplexer.Connect(connectionString); //注册如下事件--测试专用
//connect.ConnectionFailed += MuxerConnectionFailed;
//connect.ConnectionRestored += MuxerConnectionRestored;
//connect.ErrorMessage += MuxerErrorMessage;
//connect.ConfigurationChanged += MuxerConfigurationChanged;
//connect.HashSlotMoved += MuxerHashSlotMoved;
//connect.InternalError += MuxerInternalError;
return connect;
}
#endregion #region 事件 ///// <summary>
///// 配置更改时
///// </summary>
///// <param name="sender"></param>
///// <param name="e"></param>
//private static void MuxerConfigurationChanged(object sender, EndPointEventArgs e)
//{
// LogHelper.WriteLog("Configuration changed: " + e.EndPoint);
//} ///// <summary>
///// 发生错误时
///// </summary>
///// <param name="sender"></param>
///// <param name="e"></param>
//private static void MuxerErrorMessage(object sender, RedisErrorEventArgs e)
//{
// LogHelper.WriteLog("ErrorMessage: " + e.Message);
//} ///// <summary>
///// 重新建立连接之前的错误
///// </summary>
///// <param name="sender"></param>
///// <param name="e"></param>
//private static void MuxerConnectionRestored(object sender, ConnectionFailedEventArgs e)
//{
// LogHelper.WriteLog("ConnectionRestored: " + e.EndPoint);
//} ///// <summary>
///// 连接失败 ， 如果重新连接成功你将不会收到这个通知
///// </summary>
///// <param name="sender"></param>
///// <param name="e"></param>
//private static void MuxerConnectionFailed(object sender, ConnectionFailedEventArgs e)
//{
// LogHelper.WriteLog("重新连接：Endpoint failed: " + e.EndPoint + ", " + e.FailureType + (e.Exception == null ? "" : (", " + e.Exception.Message)));
//} ///// <summary>
///// 更改集群
///// </summary>
///// <param name="sender"></param>
///// <param name="e"></param>
//private static void MuxerHashSlotMoved(object sender, HashSlotMovedEventArgs e)
//{
// LogHelper.WriteLog("HashSlotMoved:NewEndPoint" + e.NewEndPoint + ", OldEndPoint" + e.OldEndPoint);
//} ///// <summary>
///// redis类库错误
///// </summary>
///// <param name="sender"></param>
///// <param name="e"></param>
//private static void MuxerInternalError(object sender, InternalErrorEventArgs e)
//{
// LogHelper.WriteLog("InternalError:Message" + e.Exception.Message);
//} #endregion 事件
}
}
注意：更改
配置appsetting.json
或者将这个写死
第一个地方：
第二个地方：
测试结果
list
注意：
/// <summary>
/// 出队||将数据从最右边边的(就是最尾部的) 并且从redis的list里面移除
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <returns></returns>
public T ListRightPop<T>(string key)
{
key = AddSysCustomKey(key);
return Do(db =>
{
var value = db.ListRightPop(key);
return ConvertObj<T>(value);
});
} /// <summary>
/// 出栈||将数据从最左边的(就是最开始的) 并且从redis的list里面移除
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <returns></returns>
public T ListLeftPop<T>(string key)
{
key = AddSysCustomKey(key);
return Do(db =>
{
var value = db.ListLeftPop(key);
return ConvertObj<T>(value);
});
}
Hash
这种存储list数组（适用于三层数据结构，前面两个键最后一个值分别是key、datakey、value）
注意： redisHelp.HashSet("a",str1,str2); "a",str1这两个参数原本有就覆盖
Set
最新文章
- 修改远程桌面端口号.bat
- 华为上机：IP地址转换
- cdoj 26 遮挡判断(shadow) 水题
- 尚学堂马士兵Oracle教程笔记
- 《转》SQL Server 2008 数据维护实务
- Linux解压缩总结
- WebDriver API 大全
- Sping 里面的适配器模式的实现
- windbg源码驱动调试 + 无源码驱动调试
- ide phpStorm 配置PHP路径并本地执行PHP脚本
- Actifio中的Group和Consistency Group
- log4j组件的用法（log4j1）
- 组件基础（参数校验和动态组件、v-once）—Vue学习笔记
- BZOJ4806(SummerTrainingDay03-K dp)
- C++连接Mysql数据库操作
- Solidity 官方文档中文版 4_Solidity 编程实例
- ES2015中let的暂时性死区(TDZ)
- unity3d 自带截屏
- how to use novaclient python api
- MySQL的GRANT命令（创建用户）