using ModelLibrary.quotedata;
using Newtonsoft.Json;
using StackExchange.Redis;
using System;
using System.Collections.Generic;
using System.Configuration;
using System.Data;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Net;
using System.Reflection;
using System.Threading.Tasks;
using Newtonsoft.Json.Linq;
using System.Text;
using System.Web.Script.Serialization;
/// <summary>
/// RedisHelperUtil 的摘要说明
/// </summary>
public class RedisHelperUtil : RedisHelper
{
public RedisHelperUtil()
{
//
// TODO: 在此处添加构造函数逻辑
//
}
#region Redis内存库连接方式
/// <summary>
/// 本地redis
/// </summary>
private static string constrStack = ConfigurationManager.ConnectionStrings["LocalKeyStack"].ConnectionString;
/// <summary>
/// 192.168.3.252
/// </summary>
// private static string constrStack = ConfigurationManager.ConnectionStrings["RedisKeyStack"].ConnectionString;
#endregion
//1069070069
#region batch写入数据
#region Batch Hash写入数据
/// <summary>
/// Batch Hash写入数据 无数据类型
/// </summary>
/// <param name="key"></param>
/// <param name="v"></param>
/// <param name="t"></param>
/// <param name="db"></param>
/// <returns></returns>
public static bool HashSetForBatch(RedisKey key, RedisValue v, RedisValue t, int db)
{
using (var connect = ConnectionMultiplexer.Connect(constrStack))
{
try
{
var client = connect.GetDatabase(db);
var batch = client.CreateBatch();
Task b = batch.HashSetAsync(key, v,t);
batch.Execute();
}
catch (Exception e){ }
return true;
}
}
/// <summary>
/// Batch Hash写入数据 数据类型T
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <param name="v"></param>
/// <param name="t"></param>
/// <param name="db"></param>
/// <returns></returns>
public static async Task< bool> HashSetForBatch<T>(RedisKey key,RedisValue v, T t, int db)
{
using (var connect = ConnectionMultiplexer.Connect(constrStack))
{
Task<bool> result=null;
try
{
var client = connect.GetDatabase(db);
var bacth = client.CreateBatch();
var b = bacth.HashSetAsync(key,v, RedisHelper.ConvertJson<T>(t));
bacth.Execute();
result = b;
}
catch (Exception e) { }
return await result;
}
}
#endregion
#region Batch Set写入数据
/// <summary>
/// Batch Set写入数据 无数据类型
/// </summary>
/// <param name="key"></param>
/// <param name="v"></param>
/// <param name="db"></param>
/// <returns></returns>
public static async Task<long> SetAddForBatch(RedisKey key, RedisValue[] v, int db)
{
using (var connect = ConnectionMultiplexer.Connect(constrStack))
{
Task<long> result = null;
try
{
var client = connect.GetDatabase(db);
var batch = client.CreateBatch();
Task<long> b = batch.SetAddAsync(key, v);
batch.Execute();
result = b;
}
catch (Exception e) { }
return await result;
}
}
/// <summary>
/// Batch Set写入数据 数据类型T
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <param name="t"></param>
/// <param name="db"></param>
/// <returns></returns>
public static async Task <bool> SetAddForBatch<T>(RedisKey key, T t, int db)
{
using (var connect = ConnectionMultiplexer.Connect(constrStack))
{
Task<bool> result = null;
try
{
var client = connect.GetDatabase(db);
var batch = client.CreateBatch();
Task<bool> b = batch.SetAddAsync(key, RedisHelper.ConvertJson<T>(t));
batch.Execute();
result = b;
}
catch { }
return await result;
}
}
#endregion
#endregion
#region bacth读取数据
#region Batch 读取Hash
/// <summary>
/// Batch 读取Hash所有的值
/// </summary>
/// <param name="key"></param>
/// <param name="db"></param>
/// <returns></returns>
public static HashEntry[] HashGetAllForBatch(RedisKey key, int db)
{
HashEntry[] hash = null;
List<Task<HashEntry[]>> valueList = new List<Task<HashEntry[]>>();
try
{
using (var connect = ConnectionMultiplexer.Connect(constrStack))
{
var client = connect.GetDatabase(db);
var batch = client.CreateBatch();
Task<HashEntry[]> tres = batch.HashGetAllAsync(key);
valueList.Add(tres);
batch.Execute();
foreach (var hashEntry in valueList)
{
hash = hashEntry.Result;
//var dic = hashEntry.Result.ToDictionary(k => k.Name, v => v.Value);
//var keys = dic.Keys;
}
}
}
catch (Exception e) { }
return hash;
}
#endregion
#region Batch 读取List
/// <summary>
/// Batch 读取List所有的值
/// </summary>
/// <param name="key"></param>
/// <param name="db"></param>
/// <returns></returns>
public static RedisValue[] ListGetAllForBatch(RedisKey key, int db)
{
RedisValue[] redis = null;
List<Task<RedisValue[]>> valueList = new List<Task<RedisValue[]>>();
try
{
using (var connect = ConnectionMultiplexer.Connect(constrStack))
{
var client = connect.GetDatabase(db);
var batch = client.CreateBatch();
Task<RedisValue[]> list = batch.ListRangeAsync(key);
valueList.Add(list);
batch.Execute();
foreach (var RedisValue in valueList)
{
redis = RedisValue.Result;
}
}
}
catch (Exception e) { }
return redis;
}
#endregion
#region Batch 读取SortedSet
/// <summary>
/// 获取SortedSet的全部数据
/// </summary>
/// <param name="key"></param>
/// <param name="db"></param>
/// <returns></returns>
public static RedisValue[] SortedSetRangeByRankAllForBatch(RedisKey key, int db)
{
RedisValue[] redis = null;
List<Task<RedisValue[]>> value = new List<Task<RedisValue[]>>();
using (var connect = ConnectionMultiplexer.Connect(constrStack))
{
try
{
var client = connect.GetDatabase(db);
var batch = client.CreateBatch();
Task<RedisValue []> list = batch.SortedSetRangeByRankAsync(key);;
value.Add(list);
batch.Execute();
foreach (var v in value)
{
redis = v.Result;
}
}
catch (Exception e) { }
return redis;
}
}
#endregion
#endregion
#region redis数据类型为string
#region 保存单个 value
/// <summary>
/// 保存单个 value
/// 设置一个string的键,如果存在 就会被重写
/// </summary>
/// <param name="TableName">表名</param>
/// <param name="value">值</param>
/// <param name="db">数据库</param>
/// <returns></returns>
public static bool StringSet(string TableName, string value, int db)
{
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
return client.GetDatabase(db).StringSet(TableName, value);
}
}
public static bool StringSet<T>(RedisKey key, T v, int db)
{
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
return client.GetDatabase(db).StringSet(key, RedisHelper.ConvertJson<T>(v));
}
}
#endregion
#region 保存多个 value
/// <summary>
/// 批量保存多个值
/// </summary>
/// <param name="TableName">数组 表名</param>
/// <param name="value">数组 值</param>
/// <param name="db"></param>
/// <returns></returns>
public static bool StringSet(string[] TableName, string[] value, int db)
{
//实例:
//string [] tabname = {"a1","a2","a3" };
//string[] key = { "key1", "key2", "key3" };
//var result = RedisHelperUtil.StringSet(tabname, key, dbt);
var count = TableName.Length;
var keyValuePair = new KeyValuePair<RedisKey, RedisValue>[count];
for (int i = 0; i < count; i++)
{
keyValuePair[i] = new KeyValuePair<RedisKey, RedisValue>(TableName[i], value[i]);
}
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
return client.GetDatabase(db).StringSet(keyValuePair);
}
}
#endregion
#region String读取单个值
/// <summary>
/// String读取单个值
/// </summary>
/// <param name="TableName">表名</param>
/// <param name="db"></param>
/// <returns></returns>
public static string StringGet(string TableName, int db)
{
//实例:
//var result = RedisHelperUtil.StringGet("a1", dbt);
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
return client.GetDatabase(db).StringGet(TableName);
}
}
/// <summary>
/// String读取单个值 数据类型T 返回对象T
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <param name="db"></param>
/// <returns></returns>
public static T StringGet<T>(RedisKey key, int db)
{
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
var value = client.GetDatabase(db).StringGet(key);
return RedisHelper.ConvertObj<T>(value);
}
}
#endregion
#region string批量读取
/// <summary>
/// string批量读取
/// </summary>
/// <param name="keyStrs"></param>
/// <param name="dbt"></param>
/// <returns></returns>
public static RedisValue[] StringGet(RedisKey[] TableName, int db)
{
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
return client.GetDatabase(db).StringGet(TableName);
}
}
/// <summary>
/// string批量读取 数据类型T 返回List<T> 集合
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <param name="db"></param>
/// <returns></returns>
public static List<T> StringGet<T>(RedisKey[] key, int db)
{
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
RedisValue[] v = client.GetDatabase(db).StringGet(key);
return RedisHelper.ConvetList<T>(v);
}
}
#endregion
#region 数字增长val
/// <summary>
/// String 数字增长val,返回自增后的值
/// </summary>
/// <param name="key"></param>
/// <param name="v"></param>
/// <param name="db"></param>
/// <returns></returns>
public static double StringIncrement(RedisKey key, double v, int db)
{
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
return client.GetDatabase(db).StringIncrement(key, v);
}
}
#endregion
#region 数字减少v
/// <summary>
/// 数字减少v,返回自减少的值
/// </summary>
/// <param name="key"></param>
/// <param name="v"></param>
/// <param name="db"></param>
/// <returns></returns>
public static double StringDecrement(RedisKey key, double v, int db)
{
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
return client.GetDatabase(db).StringDecrement(key, v);
}
}
#endregion
#endregion
#region redis数据类型为hash
#region 判断某个hash数据是否存在
/// <summary>
/// 判断某个hash数据是否存在
/// </summary>
/// <param name="TableName">表名</param>
/// <param name="dataKey">键名</param>
/// <param name="dbt">数据库名</param>
/// <returns></returns>
public static bool HashExists(string TableName, string dataKey, int dbt)
{
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
return client.GetDatabase(dbt).HashExists(TableName, dataKey);
}
}
#endregion
#region Hash 存储一个数据
/// <summary>
/// Hash 存储一个数据 数据类型T
/// 如果这个hsah不存在则创建新的hash键返回true,如果不存在则这个hash键会被重写 返回false
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="TableName">表名</param>
/// <param name="dataKey">键名</param>
/// <param name="dbt">数据库</param>
/// <param name="t">json格式字符串</param>
/// <returns></returns>
public static bool HashSet<T>(string TableName, string dataKey, int dbt, T t)
{
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
var json = RedisHelper.ConvertJson(t);
return client.GetDatabase(dbt).HashSet(TableName, dataKey, json);
}
}
/// <summary>
/// Hash 存储一个数据
/// </summary>
/// <param name="TableName"></param>
/// <param name="dataKey"></param>
/// <param name="db"></param>
/// <param name="t"></param>
/// <returns></returns>
public static bool HashSet(string TableName, string dataKey, int db, RedisValue t)
{
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
return client.GetDatabase(db).HashSet(TableName, dataKey, t);
}
}
#endregion
#region Hash一次性插入多条数据
/// <summary>
/// Hash一次性插入多条数据 数据类型 List<HashEntry> t
/// </summary>
/// <param name="key"></param>
/// <param name="v"></param>
/// <param name="t"></param>
/// <param name="db"></param>
/// <returns></returns>
public static bool HashSetMore(RedisKey key, List<HashEntry> t, int db)
{
using (var connect = ConnectionMultiplexer.Connect(constrStack))
{
connect.GetDatabase(db).HashSet(key, t.ToArray());
return true;
}
}
/// <summary>
/// hash一次性插入多条数据,数据类型 HashEntry[] v
/// </summary>
/// <param name="key"></param>
/// <param name="v"></param>
/// <param name="db"></param>
/// <returns></returns>
public static bool HashSetMore(RedisKey key, HashEntry[] v, int db)
{
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
client.GetDatabase(db).HashSet(key, v);
return true;
}
}
#endregion
#region 从hash中获取单个数据
/// <summary>
/// 从hash中获取数据 数据类型T
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="TableName"></param>
/// <param name="dataKey"></param>
/// <param name="dbt"></param>
/// <returns></returns>
public static T HashGet<T>(string TableName, string dataKey, int dbt)
{
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
string value = client.GetDatabase(dbt).HashGet(TableName, dataKey);
return RedisHelper.ConvertObj<T>(value);
}
}
/// <summary>
/// 从hash中获取数据
/// </summary>
/// <param name="TableName"></param>
/// <param name="dataKey"></param>
/// <param name="dbt"></param>
/// <returns></returns>
public static string HashGet(string TableName, string dataKey, int dbt)
{
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
string value = client.GetDatabase(dbt).HashGet(TableName, dataKey);
return value;
}
}
#endregion
#region 从hash中获取多个键值
/// <summary>
/// 从hash中获取多个键值 返回 RedisValue[]
/// </summary>
/// <param name="TableName"></param>
/// <param name="hashFields">一个键值的数组</param>
/// <param name="dbt"></param>
/// <returns></returns>
public static RedisValue[] HashValues(string TableName, RedisValue[] hashFields, int dbt)
{
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
return client.GetDatabase(dbt).HashGet(TableName, hashFields);
}
}
/// <summary>
/// 从hash中获取多个键值 返回List<T>
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <param name="v"></param>
/// <param name="db"></param>
/// <returns></returns>
public static List<T> HashValues<T>(RedisKey key, RedisValue[] v, int db)
{
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
var value = client.GetDatabase(db).HashGet(key, v);
return RedisHelper.ConvetList<T>(value);
}
}
#endregion
#region 获取整个hash的数据
/// <summary>
/// 获取hash表中的所有值 适用于数据量小
/// </summary>
/// <param name="TableName"></param>
/// <param name="dbt"></param>
/// <returns></returns>
public static HashEntry[] Hash_GetAll(string TableName, int dbt)
{
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
return client.GetDatabase(dbt).HashGetAll(TableName);
}
}
#endregion
#region 获取整个hash的Key
/// <summary>
/// 获取整个hash的Key
/// </summary>
/// <param name="TableName"></param>
/// <param name="dataKey"></param>
/// <param name="dbt"></param>
/// <returns></returns>
public static RedisValue[] HashAllKeys(string TableName, int db)
{
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
return client.GetDatabase(db).HashKeys(TableName);
}
}
#endregion
#region 获取整个hash的Value
/// <summary>
/// 获取整个hash的Value 返回RedisValue[]
/// </summary>
/// <param name="TableName"></param>
/// <param name="db"></param>
/// <returns></returns>
public static RedisValue[] HashAllValues(string TableName, int db)
{
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
return client.GetDatabase(db).HashValues(TableName);
}
}
/// <summary>
/// 获取整个hash的Value 返回List<T>
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <param name="db"></param>
/// <returns></returns>
public static List<T> HashAllValues<T>(RedisKey key, int db)
{
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
RedisValue[] v = client.GetDatabase(db).HashValues(key);
return RedisHelper.ConvetList<T>(v);
}
}
#endregion
#region 移除hash中的某个值
/// <summary>
/// 移除hash中的某个值
/// </summary>
/// <param name="TableName"></param>
/// <param name="dataKey"></param>
/// <param name="dbt"></param>
/// <returns></returns>
public static bool HashDelete(string TableName, string dataKey, int dbt)
{
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
return client.GetDatabase(dbt).HashDelete(TableName, dataKey);
}
}
#endregion
#region 移除hash中多个值
/// <summary>
/// 移除hash中多个值
/// </summary>
/// <param name="TableName"></param>
/// <param name="dataKey"></param>
/// <param name="dbt"></param>
/// <returns></returns>
public static long HashDelete(string TableName, List<RedisValue> dataKey, int dbt)
{
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
return client.GetDatabase(dbt).HashDelete(TableName, dataKey.ToArray());
}
}
public static long HashDelete(string TableName, RedisValue[] Rvalue, int db)
{
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
return client.GetDatabase(db).HashDelete(TableName, Rvalue);
}
}
#endregion
#region 为数字增长 V
/// <summary>
/// 为数字增长 V
/// </summary>
/// <param name="TableName"></param>
/// <param name="dataKey"></param>
/// <param name="dbt"></param>
/// <param name="v">可以是负数</param>
/// <returns></returns>
public static double HashIncrement(string TableName, string dataKey, int dbt, double v = 1)
{
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
return client.GetDatabase(dbt).HashIncrement(TableName, dataKey, v);
}
}
#endregion
#region 为数字减少 V
/// <summary>
/// 为数字减少 V
/// </summary>
/// <param name="TableName"></param>
/// <param name="dataKey"></param>
/// <param name="dbt"></param>
/// <param name="v">可以是负数</param>
/// <returns></returns>
public static double HashDecrement(string TableName, string dataKey, int dbt, double v = 1)
{
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
return client.GetDatabase(dbt).HashDecrement(TableName, dataKey, v);
}
}
#endregion
#region 返回hash中的长度
/// <summary>
/// 返回hash中的长度
/// </summary>
/// <param name="TableName"></param>
/// <param name="key"></param>
/// <param name="dbt"></param>
/// <returns></returns>
public static long HashLength(string TableName, string key, int dbt)
{
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
return client.GetDatabase(dbt).HashLength(TableName);
}
}
#endregion
#endregion
#region redis数据类型为list
#region 从key的list中取出所有的数据
/// <summary>
/// 从key的list中取出所有的数据
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="TableName"></param>
/// <param name="db"></param>
/// <returns>并且数据结构为JSON格式</returns>
public static List<T> ListRange<T>(string TableName, int db)
{
//实例
//List<JsonObject> li = new List<JsonObject>();
//li = RedisHelperUtil.ListRange<JsonObject>("abc", 3);
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
return RedisHelper.ConvetList<T>(client.GetDatabase(db).ListRange(TableName));
}
}
public static List<T> ListRange<T>(string TableName, int db,int start,int stop)
{
//实例
//List<JsonObject> li = new List<JsonObject>();
//li = RedisHelperUtil.ListRange<JsonObject>("abc", 3);
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
return RedisHelper.ConvetList<T>(client.GetDatabase(db).ListRange(TableName,start,stop));
}
}
/// <summary>
/// 从key的list中取出所有的数据
/// </summary>
/// <param name="TableName"></param>
/// <param name="db"></param>
/// <returns></returns>
public static RedisValue[] ListRange(string TableName, int db)
{
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
return client.GetDatabase(db).ListRange(TableName);
}
}
public static RedisValue[] ListRange(RedisKey key, int db, long start, long stop)
{
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
return client.GetDatabase(db).ListRange(key, start, stop);
}
}
#endregion
#region 从左侧(头部)向list中添加一个值
/// <summary>
/// 从左侧向list中添加一个值(无格式类型),返回集合总数
/// </summary>
/// <param name="TableName"></param>
/// <param name="value"></param>
/// <param name="db"></param>
/// <returns></returns>
public static long ListLeftPush(string TableName, RedisValue value, int db)
{
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
return client.GetDatabase(db).ListLeftPush(TableName, value);
}
}
/// <summary>
/// 从左侧向list中添加一个值(JSON格式),返回集合总数
/// </summary>
/// <typeparam name="T">实体</typeparam>
/// <param name="TableName"></param>
/// <param name="value"></param>
/// <param name="db"></param>
/// <returns>插入数据的表的数据结构要一致并且数据结构为JSON格式</returns>
public static long ListLeftPush<T>(string TableName, T t, int db)
{
string JsonStr = JsonHelperUtil.ConvertJson(t);
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
return client.GetDatabase(db).ListLeftPush(TableName, JsonStr);
}
}
#endregion
#region 从左侧(头部)向list中添加多个值
/// <summary>
/// 从左侧(头部)向list中添加多个值
/// </summary>
/// <param name="TableName"></param>
/// <param name="v"></param>
/// <param name="db"></param>
/// <returns></returns>
public static long ListLeftPush(string TableName, RedisValue[] v, int db)
{
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
return client.GetDatabase(db).ListLeftPush(TableName, v);
}
}
/// <summary>
/// 从左侧向list中添加多个值
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="TableName"></param>
/// <param name="values"></param>
/// <param name="db"></param>
/// <returns></returns>
public static long ListLeftPush<T>(string TableName, List<T> values, int db)
{
//事例:
//List<string> tt = new List<string>();
//tt.Add("a1");
//tt.Add("a2");
//tt.Add("a3");
//var r = RedisHelperUtil.ListLeftPush(tab, tt, dbt);
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
RedisValue[] valueList = RedisHelper.ConvertRedisValue(values.ToArray());
return client.GetDatabase(db).ListLeftPush(TableName, valueList);
}
}
#endregion
#region 从右侧(尾部)向list添加一个值
/// <summary>
/// 从右侧(尾部)向list添加一个值(无格式)
/// </summary>
/// <param name="TableName"></param>
/// <param name="value"></param>
/// <param name="db"></param>
/// <returns></returns>
public static long ListRightPush(string TableName, RedisValue value, int db)
{
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
return client.GetDatabase(db).ListRightPush(TableName, value);
}
}
/// <summary>
/// 从右侧(尾部)向list添加一个值(JSON格式)
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="TableName"></param>
/// <param name="t"></param>
/// <param name="db"></param>
/// <returns></returns>
public static long ListRightPush<T>(string TableName, T t, int db)
{
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
var v = RedisHelper.ConvertJson(t);
return client.GetDatabase(db).ListRightPush(TableName, v);
}
}
#endregion
#region 从右侧(尾部)向list添加多个值
public static long ListRightPush(string TableName, RedisValue[] v, int db)
{
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
return client.GetDatabase(db).ListRightPush(TableName, v);
}
}
/// <summary>
/// 从右侧(尾部)向list添加多个值
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="TableName"></param>
/// <param name="t"></param>
/// <param name="db"></param>
/// <returns></returns>
public static long ListRightPush<T>(string TableName, List<T> t, int db)
{
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
RedisValue[] values = RedisHelper.ConvertRedisValue(t.ToArray());
return client.GetDatabase(db).ListRightPush(TableName, values);
}
}
#endregion
#region 从左侧(头部)向list中取出一个值 并且删除
/// <summary>
/// 从左侧(头部)向list中取出一个值 并且删除
/// </summary>
/// <param name="TableNme"></param>
/// <param name="db"></param>
/// <returns>返回一个值</returns>
public static RedisValue ListLeftPop(string TableNme, int db)
{
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
return (client.GetDatabase(db).ListLeftPop(TableNme));
}
}
/// <summary>
/// /// <summary>
/// 从左侧(头部)向list中取出一个值 返回对象
/// </summary>
/// <param name="TableNme"></param>
/// <param name="db"></param>
/// <returns>返回一个对象</returns>
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="TableName"></param>
/// <param name="db"></param>
/// <returns></returns>
public static T ListLeftPop<T>(string TableName, int db)
{
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
return RedisHelper.ConvertObj<T>(client.GetDatabase(db).ListLeftPop(TableName));
}
}
#endregion
#region 从右侧(尾部)向list中取出一个值并且删除
/// <summary>
/// 从右侧(尾部)向list中取出一个值并且删除
/// </summary>
/// <param name="TableName"></param>
/// <param name="db"></param>
/// <returns></returns>
public static RedisValue ListRightPop(string TableName, int db)
{
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
return client.GetDatabase(db).ListRightPop(TableName);
}
}
/// <summary>
/// 从右侧(尾部)向list中取出一个值 返回对象
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="TableName"></param>
/// <param name="db"></param>
/// <returns></returns>
public static T ListRightPop<T>(string TableName, int db)
{
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
return RedisHelper.ConvertObj<T>(client.GetDatabase(db).ListRightPop(TableName));
}
}
#endregion
#region 从在xx之后入列
/// <summary>
/// 从在xx之后(右侧尾部)入列
/// </summary>
/// <param name="TableName">表名</param>
/// <param name="pivot">在pivot之后插入</param>
/// <param name="v">插入值为v</param>
/// <param name="db"></param>
/// <returns></returns>
public static long ListInsertAfter(string TableName, RedisValue pivot, RedisValue v, int db)
{
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
return client.GetDatabase(db).ListInsertAfter(TableName, pivot, v);
}
}
public static long ListInsertAfter<T>(RedisKey key, RedisValue pivot, T t, int db)
{
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
return client.GetDatabase(db).ListInsertAfter(key, pivot, RedisHelper.ConvertJson<T>(t));
}
}
#endregion
#region 从在xx之前入列
/// <summary>
/// 从在xx之前入列
/// </summary>
/// <param name="TableName"></param>
/// <param name="pivot">在pivot前面插入(左侧。前方)</param>
/// <param name="v">插入v</param>
/// <param name="db"></param>
/// <returns></returns>
public static long ListInsertBefore(string TableName, RedisValue pivot, RedisValue v, int db)
{
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
return client.GetDatabase(db).ListInsertBefore(TableName, pivot, v);
}
}
public static long ListInsertBefore<T>(string TableName, RedisValue pivot,T t, int db)
{
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
return client.GetDatabase(db).ListInsertBefore(TableName, pivot, RedisHelper.ConvertJson<T>(t));
}
}
#endregion
#region 从第几个后面入列
/// <summary>
/// 从第几个后面入列
/// </summary>
/// <param name="TableName"></param>
/// <param name="index"></param>
/// <param name="value"></param>
/// <param name="db"></param>
public static void ListSetByIndex(string TableName, long index, RedisValue value, int db)
{
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
client.GetDatabase(db).ListSetByIndex(TableName, index, value);
}
}
#endregion
#region 根据index获取(下标0开始)
/// <summary>
/// 根据index获取(下标0开始)
/// </summary>
/// <param name="TableName"></param>
/// <param name="index"></param>
/// <param name="db"></param>
public static RedisValue ListGetByIndex(string TableName, long index, int db)
{
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
return client.GetDatabase(db).ListGetByIndex(TableName, index);
}
}
#endregion
#region list集合长度
/// <summary>
/// 返回list集合长度
/// </summary>
/// <param name="TableName"></param>
/// <param name="db"></param>
/// <returns></returns>
public static long ListLength(string TableName, int db)
{
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
return client.GetDatabase(db).ListLength(TableName);
}
}
#endregion
#region 从key的List中移除指定的值,返回删除个数
/// <summary>
/// 从key的List中移除指定的值,返回删除个数
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="TableName"></param>
/// <param name="t"></param>
/// <param name="db"></param>
/// <returns></returns>
public static long ListRemove(string TableName, RedisValue v, int db)
{
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
return client.GetDatabase(db).ListRemove(TableName, v);
}
}
#endregion
#endregion
#region redis数据类型为set
#region 在key集合中添加一个value值
/// <summary>
/// 在key集合中添加一个value值
/// </summary>
/// <param name="TableName"></param>
/// <param name="v"></param>
/// <param name="db"></param>
/// <returns></returns>
public static bool SetAdd(string TableName, RedisValue v, int db)
{
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
return client.GetDatabase(db).SetAdd(TableName, v);
}
}
#endregion
#region 在key集合中添加多个value值
/// <summary>
/// 在key集合中添加一个或多个value值
/// </summary>
/// <param name="TableName"></param>
/// <param name="v"></param>
/// <param name="db"></param>
/// <returns></returns>
public static long SetAdd(string TableName, RedisValue[] v, int db)
{
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
return client.GetDatabase(db).SetAdd(TableName, v);
}
}
#endregion
#region 获取Key所有值的集合
/// <summary>
/// 获取Key所有值的集合
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="TableName"></param>
/// <param name="db"></param>
/// <returns></returns>
public static RedisValue[] SetMembers(string TableName, int db)
{
#region 实例 :
//RedisValue[] r = RedisHelperUtil.SetMembers("SetV", 3);
//var rr = r[1];
#endregion
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
return client.GetDatabase(db).SetMembers(TableName);
}
}
#endregion
#region 获取key集合的数量
/// <summary>
/// 获取key集合的数量
/// </summary>
/// <param name="TableName"></param>
/// <param name="db"></param>
/// <returns></returns>
public static long SetLength(string TableName, int db)
{
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
return client.GetDatabase(db).SetLength(TableName);
}
}
#endregion
#region 判断Key集合中是否包含指定的值
/// <summary>
/// 判断Key集合中是否包含指定的值
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="TableName"></param>
/// <param name="t"></param>
/// <param name="db"></param>
/// <returns></returns>
///
public static bool SetContains(string TableName, RedisValue v, int db)
{
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
return client.GetDatabase(db).SetContains(TableName, v);
}
}
#endregion
#region 删除key集合中指定的value
/// <summary>
/// 删除key集合中指定的value
/// </summary>
/// <param name="TableName"></param>
/// <param name="datakey"></param>
/// <param name="db"></param>
public static bool SetRemove(string TableName, string datakey, int db)
{
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
return client.GetDatabase(db).SetRemove(TableName, datakey);
}
}
#endregion
#endregion
#region redis数据类型为SortedSet
#region 添加一个值到Key
/// <summary>
/// 添加一个值到Key
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="TableName"></param>
/// <param name="t"></param>
/// <param name="score"></param>
/// <param name="db"></param>
/// <returns></returns>
public static bool SortedSetAdd<T>(string TableName, T t, double score, int db)
{
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
return client.GetDatabase(db).SortedSetAdd(TableName, RedisHelper.ConvertJson<T>(t), score);
}
}
/// <summary>
/// 添加一个或多个值
/// </summary>
/// <param name="TableName"></param>
/// <param name="v"></param>
/// <param name="score"></param>
/// <param name="db"></param>
/// <returns></returns>
public static long SortedSetAdd(string TableName, SortedSetEntry[] v, double score, int db)
{
//实例:
//SortedSetEntry[] v = {new SortedSetEntry("a",2),new SortedSetEntry("b",2)};
//var l = RedisHelperUtil.SortedSetAdd("SortedOne",v,2,3);
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
return client.GetDatabase(db).SortedSetAdd(TableName, v);
}
}
#endregion
#region 添加一个集合到Key
/// <summary>
/// 添加一个集合到Key
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="TableName"></param>
/// <param name="value"></param>
/// <param name="score"></param>
/// <param name="db"></param>
/// <returns></returns>
public static long SortedSetAdd<T>(string TableName, List<T> value, double score, int db)
{
#region 实例
//List<string> l = new List<string>();
//l.Add("aa");
//l.Add("bb");
//var t = RedisHelperUtil.SortedSetAdd<string>("Test", l, 2, 3);
#endregion
SortedSetEntry[] Svalue = value.Select(o => new SortedSetEntry(RedisHelper.ConvertJson<T>(o), score)).ToArray();
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
return client.GetDatabase(db).SortedSetAdd(TableName, Svalue);
}
}
#endregion
#region 获取SortedSet的全部数据 或者从start开始到stop条的数据
/// <summary>
/// 获取SortedSet的全部数据
/// 或者从start开始到stop条的数据
/// </summary>
/// <param name="TableName"></param>
/// <param name="db"></param>
/// <param name="start">起始数</param>
/// <param name="stop">-1表示到结束,0为1条</param>
/// <param name="desc">是否按降序排列</param>
/// <returns></returns>
public static RedisValue[] SortedSetRangeByRankAll(string TableName, int db)
{
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
return client.GetDatabase(db).SortedSetRangeByRank(TableName);
}
}
public static RedisValue[] SortedSetRangeByRankAll(string TableName, int db, long start = 0, long stop = -1, bool desc = false)
{
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
start = start == 0 ? 0 : start;
stop = stop == -1 ? -1 : stop;
Order orderBy = desc ? Order.Descending : Order.Ascending;
return client.GetDatabase(db).SortedSetRangeByRank(TableName, start, stop, orderBy);
}
}
#endregion
#region 获取SortedSet的分页数据
/// <summary>
/// 获取SortedSet的分页数据
/// </summary>
/// <param name="TableName"></param>
/// <param name="pageIndex">页码</param>
/// <param name="pageSize">页大小</param>
/// <param name="db"></param>
/// <returns></returns>
public static RedisValue[] SortedSetRangeByRank(string TableName, int pageIndex, int pageSize, int db)
{
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
return client.GetDatabase(db).SortedSetRangeByRank(TableName, (pageIndex - 1) * pageSize, pageIndex * pageSize - 1);
}
}
#endregion
#region 获取指定key的排序Score值
/// <summary>
/// 获取制定key的排序Score值
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="TableName"></param>
/// <param name="t"></param>
/// <param name="db"></param>
/// <returns></returns>
public static double? SortedSetScore(string TableName, RedisValue v, int db)
{
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
return client.GetDatabase(db).SortedSetScore(TableName, v);
}
}
public static double? SortedSetScore<T>(string TableName, T t, int db)
{
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
return client.GetDatabase(db).SortedSetScore(TableName, RedisHelper.ConvertJson<T>(t));
}
}
#endregion
#region 获取集合中的数量
/// <summary>
/// 获取集合中的数量
/// </summary>
/// <param name="TableName"></param>
/// <param name="db"></param>
/// <returns></returns>
public static long SortedSetLength(string TableName, int db)
{
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
return client.GetDatabase(db).SortedSetLength(TableName);
}
}
#endregion
#region 移除数据从SortedSet
/// <summary>
/// 移除数据从SortedSet
/// </summary>
/// <param name="TableName"></param>
/// <param name="v"></param>
/// <param name="db"></param>
/// <returns></returns>
public static long SortedSetRemove(string TableName, RedisValue[] v, int db)
{
using (var client = ConnectionMultiplexer.Connect(constrStack))
{
return client.GetDatabase(db).SortedSetRemove(TableName, v);
}
}
#endregion
#endregion
}
StackExchange.redis 封装帮助类
猜你喜欢
转载自blog.csdn.net/smile06211114/article/details/79899570
今日推荐
周排行