kxs-admin/AppStart/Redis/CustomRedisDbconn.cs

using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using CSRedis;
using Library;
using System.Linq;

namespace MySystem
{
    public class CustomRedisDbconn
    {
        public CSRedis.CSRedisClient csredis;
        public CustomRedisDbconn(string key, int Database = 0)
        {
            string connstr = Library.ConfigurationManager.AppSettings[key].ToString();
            csredis = new CSRedis.CSRedisClient(connstr);
        }

        #region 设置单个字段
        public bool Set(string key, object value, int sec = -1)
        {
            return csredis.Set(key, value, sec);
            // return false;
        }
        #endregion

        #region 整数累加
        public long AddInt(string key, long value = 1)
        {
            return csredis.IncrBy(key, value);
            // return 0;
        }
        #endregion

        #region 数字累加
        public decimal AddNumber(string key, decimal value = 1)
        {
            return csredis.IncrByFloat(key, value);
            // return 0;
        }
        #endregion

        #region 获取单个字段
        public T Get<T>(string key)
        {
            return csredis.Get<T>(key);
        }
        #endregion

        #region 设置散列字段
        public bool HSet(string key, string field, object value)
        {
            return csredis.HSet(key, field, value);
            // return false;
        }
        #endregion

        #region 散列整数累加
        public long HAddInt(string key, string field, long value = 1)
        {
            return csredis.HIncrBy(key, field, value);
            // return 0;
        }
        #endregion

        #region 散列数字累加
        public decimal HAddNumber(string key, string field, decimal value = 1)
        {
            return csredis.HIncrByFloat(key, field, value);
            // return 0;
        }
        #endregion

        #region 获取散列元素
        public T HGet<T>(string key, string field)
        {
            return csredis.HGet<T>(key, field);
        }
        #endregion

        #region 获取散列所有元素
        public Dictionary<string, T> HGetAll<T>(string key)
        {
            return csredis.HGetAll<T>(key);
        }
        #endregion

        #region 添加列表对象
        public long AddList(string key, object value)
        {
            return csredis.LPush(key, value);
            // return 0;
        }
        public long AddList(string key, object[] value)
        {
            return csredis.LPush(key, value);
            // return 0;
        }
        public long AddRightList(string key, object value)
        {
            return csredis.RPush(key, value);
            // return 0;
        }
        public T RPop<T>(string key)
        {
            return csredis.RPop<T>(key);
        }
        #endregion

        #region 添加集合对象
        public long SAdd(string key, object value)
        {
            return csredis.SAdd(key, value);
            // return 0;
        }
        public long SAdd(string key, object[] value)
        {
            return csredis.SAdd(key, value);
            // return 0;
        }
        #endregion

        #region 获取集合对象
        public T[] SGetList<T>(string key)
        {
            return csredis.SMembers<T>(key);
        }
        #endregion

        #region 判断元素是否存在
        public bool SIsMember(string key, object value)
        {
            return csredis.SIsMember(key, value);
        }
        #endregion

        #region 修改列表对象
        public bool SetList(string key, int index, object value)
        {
            long itemindex = csredis.LLen(key) - index - 1;
            return csredis.LSet(key, itemindex, value);
            // return false;
        }
        #endregion

        #region 删除列表对象
        public long DelFromList(string key, object value)
        {
            return csredis.LRem(key, 0, value);
            // return false;
        }
        #endregion

        #region 获取列表
        public List<T> GetList<T>(string key, int pageNum = 1, int pageSize = 10)
        {
            int start = (pageNum - 1) * pageSize;
            int end = start + pageSize - 1;
            T[] list = csredis.LRange<T>(key, start, end);
            return list.ToList();
        }
        #endregion

        #region 添加排序列表对象
        public long AddSort(string key, object value, decimal score)
        {
            return csredis.ZAdd(key, (score, value));
            // return 0;
        }
        #endregion

        #region 获取排序列表
        public List<T> GetSort<T>(string key, int pageNum = 1, int pageSize = 10)
        {
            int start = (pageNum - 1) * pageSize;
            int end = start + pageSize;
            string[] list = csredis.ZRangeByScore(key, start, end);
            List<T> lists = new List<T>();
            foreach (string record in list)
            {
                lists.Add(Newtonsoft.Json.JsonConvert.DeserializeObject<T>(record));
            }
            return lists;
        }
        public List<T> GetSortDesc<T>(string key, int pageNum = 1, int pageSize = 10)
        {
            int start = (pageNum - 1) * pageSize;
            int end = start + pageSize;
            string[] list = csredis.ZRevRangeByScore(key, start, end);
            List<T> lists = new List<T>();
            foreach (string record in list)
            {
                lists.Add(Newtonsoft.Json.JsonConvert.DeserializeObject<T>(record));
            }
            return lists;
        }
        #endregion

        public bool Remove(string key, long start, long end)
        {
            return csredis.LTrim(key, start, end);
        }

        public bool RemoveTop(string key, long count)
        {
            return RedisDbconn.Instance.Remove(key, count, RedisDbconn.Instance.Count(key) - 1); ;
        }

        public long Count(string key)
        {
            return csredis.LLen(key);
        }

        public void Clear(string pattern)
        {
            string[] keys = csredis.Keys(pattern);
            csredis.Del(keys);
        }

        public string[] GetKeys(string pattern)
        {
            string[] keys = csredis.Keys(pattern);
            return keys;
        }

        public bool Exists(string key)
        {
            return csredis.Exists(key);
        }

        public bool HExists(string key, string field)
        {
            return csredis.HExists(key, field);
        }        

        public void SetExpire(string key, int expire)
        {
            csredis.Expire(key, expire); //秒为单位
        }




        /// <summary>
        /// 锁key
        /// </summary>
        private readonly string lockKey = "RedisLock";
        /// <summary>
        /// 锁的过期秒数
        /// </summary>
        private readonly int lockTime = 20;
        /// <summary>
        /// 续命线程取消令牌
        /// </summary>
        private CancellationTokenSource tokenSource = new CancellationTokenSource();

        /// <summary>
        /// 获取锁
        /// </summary>
        /// <param name="requestId">请求id保证释放锁时的客户端和加锁的客户端一致</param>
        /// <returns></returns>
        public bool GetLock(string requestId)
        {
            //设置key 设置过期时间20s
            while (true)
            {
                //设置key Redis2.6.12以上版本，可以用set获取锁。set可以实现setnx和expire，这个是原子操作
                if (csredis.Set(lockKey, requestId, lockTime, RedisExistence.Nx))
                {
                    //设置成功后开启子线程为key续命
                    CreateThredXm();
                    return true;
                }
            }
        }
        /// <summary>
        /// 为锁续命(防止业务操作时间大于锁自动释放时间，锁被自动释放掉)
        /// </summary>
        void CreateThredXm()
        {
            Task.Run(() =>
            {
                while (true)
                {
                    Thread.Sleep(10);
                    //外部取消 退出子线程
                    if (tokenSource.IsCancellationRequested)
                    {
                        return;
                    }
                    //查询key还有多少秒释放
                    var Seconds = csredis.PTtl(lockKey) / 1000;
                    //key还剩1/3秒时重设过期时间
                    if (Seconds < (lockTime / 3))
                    {
                        //小于5秒则自动 重设过期时间
                        csredis.Expire(lockKey, lockTime);
                    }
                }
            }, tokenSource.Token);
        }
        /// <summary>
        /// 释放锁操作
        /// </summary>
        /// <param name="requestId">请求id保证释放锁时的客户端和加锁的客户端一致</param>
        public void ReleaseLock(string requestId)
        {
            //这里使用Lua脚本保证原子性操作
            string script = "if  redis.call('get', KEYS[1]) == ARGV[1] then " +
                    "return redis.call('del', KEYS[1]) " +
                    "else return 0 end";
            csredis.Eval(script, lockKey, requestId);
            //取消续命线程
            tokenSource.Cancel();
        }
    }
}