StackExchange.Redis 二次封装

在NuGet直接搜索StackExchange.Redis，下载引用包；

帮助类

/***********************************
 * Developer: Lio.Huang
 * Date：2018-11-21
 **********************************/
using System;
using System.Collections.Generic;
using System.Linq;
using StackExchange.Redis;
using Newtonsoft.Json;
using System.Threading.Tasks;

namespace Banana.Utility.Redis
{
    /// 
    /// Redis Base Utils
    /// 
    public class RedisUtils
    {
        ///   
        /// redis配置文件信息  
        ///   
        public static string RedisPath = "172.16.3.82:6379";

        /// 
        /// 注册地址
        /// 
        /// redis connection string
        public static void Register(string redisPath)
        {
            RedisPath = redisPath;
        }

        private static ConnectionMultiplexer _instance = null;

        /// 
        /// 使用一个静态属性来返回已连接的实例，如下列中所示。这样，一旦 ConnectionMultiplexer 断开连接，便可以初始化新的连接实例。
        /// 
        public static ConnectionMultiplexer Instance
        {
            get
            {
                return conn.Value;
            }
        }

        //public static ConnectionMultiplexer Instance
        //{
        //    get
        //    {
        //        //if (_instance == null)
        //        //{
        //        //    lock (_locker)
        //        //    {
        //        if (_instance == null || !_instance.IsConnected)
        //        {
        //            _instance = ConnectionMultiplexer.Connect(RedisPath);
        //            //注册如下事件
        //            _instance.ConnectionFailed += MuxerConnectionFailed;
        //            _instance.ConnectionRestored += MuxerConnectionRestored;
        //            _instance.ErrorMessage += MuxerErrorMessage;
        //            _instance.HashSlotMoved += MuxerHashSlotMoved;
        //            _instance.InternalError += MuxerInternalError;
        //        }
        //        //    }
        //        //}
        //        return _instance;
        //    }
        //}

        private static Lazy conn = new Lazy(
        () =>
        {
            _instance = ConnectionMultiplexer.Connect(RedisPath);
            //注册如下事件
            _instance.ConnectionFailed += MuxerConnectionFailed;
            _instance.ConnectionRestored += MuxerConnectionRestored;
            _instance.ErrorMessage += MuxerErrorMessage;
            _instance.HashSlotMoved += MuxerHashSlotMoved;
            _instance.InternalError += MuxerInternalError;
            return _instance;
        }
        );

        #region Keys
        /// 
        /// 判断键是否存在
        /// 
        /// 数据库
        /// 键值
        /// 
        public static bool KeyExists(int dbIndex, string key)
        {
            var db = Instance.GetDatabase(dbIndex);
            return db.KeyExists(key);
        }

        /// 
        /// 为指定的键设置失效时间
        /// 
        /// 数据库
        /// 键
        /// 时间间隔
        /// 
        public static bool SetExpire(int dbIndex, string key, TimeSpan? expiry)
        {
            var db = Instance.GetDatabase(dbIndex);
            return db.KeyExpire(key, expiry);
        }

        /// 
        ///  为指定的键设置失效时间
        ///  
        /// 数据库
        /// 键
        /// 时间间隔（秒）
        /// 
        public static bool SetExpire(int dbIndex, string key, int timeout = 0)
        {
            var db = Instance.GetDatabase(dbIndex);
            return db.KeyExpire(key, DateTime.Now.AddSeconds(timeout));
        }

        /// 
        ///  删除键
        /// 
        /// 数据库
        /// 键
        /// 
        public static bool KeyDelete(int dbIndex, string key)
        {
            var db = Instance.GetDatabase(dbIndex);
            return db.KeyDelete(key);
        }

        /// 
        ///  键重命名
        /// 
        /// 数据库
        /// 旧值
        /// 新值
        /// 
        public static bool KeyRename(int dbIndex, string oldKey, string newKey)
        {
            var db = Instance.GetDatabase(dbIndex);
            return db.KeyRename(oldKey, newKey);
        }
        #endregion

        #region Strings
        /// 
        /// 获取字符串数据
        /// 
        /// 
        /// 数据库
        /// Redis键
        /// 
        public static string StringGet(int dbIndex, string key)
        {
            var db = Instance.GetDatabase(dbIndex);
            if (db != null)
            {
                return db.StringGet(key);
            }
            return string.Empty;
        }

        /// 
        /// 获取对象类型数据
        /// 
        /// 
        /// 数据库
        /// Redis键
        /// 
        public static T StringGet(int dbIndex, string key) where T : class
        {
            T data = default(T);
            var db = Instance.GetDatabase(dbIndex);
            if (db != null)
            {
                var value = db.StringGet(key);
                return ConvertObj(value);
            }
            return data;
        }

        /// 
        /// 设置值类型的值
        /// 
        /// 数据库
        /// 键
        /// 值
        public static bool StringSet(int dbIndex, string key, RedisValue value, TimeSpan? expiry)
        {
            var db = Instance.GetDatabase(dbIndex);
            return db.StringSet(key, value, expiry);
        }

        /// 
        /// 设置对象类型的值
        /// 
        /// 数据库
        /// 键
        /// 值
        public static bool StringSet(int dbIndex, string key, T value, TimeSpan? expiry) where T : class
        {
            if (value == default(T))
            {
                return false;
            }
            var db = Instance.GetDatabase(dbIndex);
            return db.StringSet(key, ConvertJson(value), expiry);
        }
        #endregion

        #region Hashes
        /// 
        /// Hash是否存在
        /// 
        /// 数据库
        /// HashId
        /// 键
        /// 
        public static bool HashExists(int dbIndex, string hashId, string key)
        {
            var db = Instance.GetDatabase(dbIndex);
            return db.HashExists(key, hashId);
        }

        /// 
        /// Hash长度
        /// 
        /// 数据库
        /// HashId
        /// 
        public static long HashLength(int dbIndex, string hashId)
        {
            var db = Instance.GetDatabase(dbIndex);
            var length = db.HashLength(hashId);
            return length;
        }

        /// 
        /// 设置哈希值
        /// 
        /// 哈希值类型
        /// 数据库
        /// 哈希ID
        /// 键
        /// 哈希值
        /// 
        public static bool HashSet(int dbIndex, string hashId, string key, T t)
        {
            var db = Instance.GetDatabase(dbIndex);
            return db.HashSet(hashId, key, ConvertJson(t));
        }

        /// 
        ///   获取哈希值
        /// 
        /// 哈希值类型
        /// 数据库
        /// 哈希ID
        /// 键
        /// 
        public static T HashGet(int dbIndex, string hashId, string key)
        {
            var db = Instance.GetDatabase(dbIndex);
            string value = db.HashGet(hashId, key);
            if (string.IsNullOrWhiteSpace(value))
                return default(T);
            return ConvertObj(value);
        }

        /// 
        ///   获取哈希值
        /// 
        /// 数据库
        /// 哈希ID
        /// 键
        /// 
        public static string HashGet(int dbIndex, string hashId, string key)
        {
            var db = Instance.GetDatabase(dbIndex); 
            return db.HashGet(hashId, key).ToString();
        }

        /// 
        /// 获取哈希值的所有键
        /// 
        /// 数据库
        /// 哈希ID
        /// 
        public static List<string> HashKeys(int dbIndex, string hashId)
        {
            var db = Instance.GetDatabase(dbIndex);
            var result = new List<string>();
            var list = db.HashKeys(hashId).ToList();
            if (list.Count > 0)
            {
                list.ForEach(x =>
                {
                    result.Add(ConvertObj<string>(x));
                });
            }
            return result;
        }

        /// 
        /// 获取所有哈希值
        /// 
        /// 哈希值类型
        /// 数据库
        /// 哈希ID
        /// 
        public static List HashGetAll(int dbIndex, string hashId)
        {
            var db = Instance.GetDatabase(dbIndex);
            var result = new List();
            var list = db.HashGetAll(hashId).ToList();
            if (list.Count > 0)
            {
                list.ForEach(x =>
                {
                    result.Add(ConvertObj(x.Value));
                });
            }
            return result;
        }

        /// 
        ///  删除哈希值
        /// 
        /// 数据库
        /// 哈希ID
        /// 键
        /// 
        public static bool HashDelete(int dbIndex, string hashId, string key)
        {
            var db = Instance.GetDatabase(dbIndex);
            return db.HashDelete(hashId, key);
        }
        #endregion

        #region Lists
        /// 
        /// 集合长度
        /// 
        /// 数据库
        /// 集合ID
        /// 
        public static long ListLength(int dbIndex, string listId)
        {
            var db = Instance.GetDatabase(dbIndex);
            return db.ListLength(listId);
        }

        /// 
        /// 向集合中添加元素
        /// 
        /// 元素类型
        /// 数据库
        /// 集合ID
        /// 元素值
        /// 
        public static long AddList(int dbIndex, string listId, List list)
        {
            var db = Instance.GetDatabase(dbIndex);
            if (list != null && list.Count > 0)
            {
                foreach (var item in list)
                {
                    db.ListRightPush(listId, ConvertJson(item));
                }
            }
            return db.ListLength(listId);
        }

        /// 
        /// 获取集合元素(默认获取整个集合)
        /// 
        /// 元素类型
        /// 数据库
        /// 集合ID
        /// 起始位置(0表示第1个位置)
        /// 结束位置(-1表示倒数第1个位置)
        /// 
        public static List GetList(int dbIndex, string listId, long start = 0, long stop = -1)
        {
            var db = Instance.GetDatabase(dbIndex);
            var result = new List();
            var list = db.ListRange(listId, start, stop).ToList();
            if (list.Count > 0)
            {
                list.ForEach(x =>
                {
                    result.Add(ConvertObj(x));
                });
            }
            return result;
        }
        #endregion

        #region ZSet

        #region 同步方法

        /// 
        /// 添加一个值到Key
        /// 
        /// 
        /// 数据库
        /// 
        /// 
        /// 排序分数，为空将获取集合中最大score加1
        /// 
        public static bool SortedSetAdd(int dbIndex, string key, T value, double? score = null)
        {
            var db = Instance.GetDatabase(dbIndex);
            double scoreNum = score ?? _GetScore(key, db);
            return db.SortedSetAdd(key, ConvertJson(value), scoreNum);
        }

        /// 
        /// 添加一个集合到Key
        /// 
        /// 
        /// 数据库
        /// 
        /// 
        /// 排序分数，为空将获取集合中最大score加1
        /// 
        public static long SortedSetAdd(int dbIndex, string key, List value, double? score = null)
        {
            var db = Instance.GetDatabase(dbIndex);
            double scoreNum = score ?? _GetScore(key, db);
            SortedSetEntry[] rValue = value.Select(o => new SortedSetEntry(ConvertJson(o), scoreNum++)).ToArray();
            return db.SortedSetAdd(key, rValue);
        }

        /// 
        /// 获取集合中的数量
        /// 
        /// 数据库
        /// 
        /// 
        public static long SortedSetLength(int dbIndex,string key)
        {
            var db = Instance.GetDatabase(dbIndex);
            return db.SortedSetLength(key);
        }

        /// 
        /// 获取指定起始值到结束值的集合数量
        /// 
        /// 
        /// 数据库
        /// 
        /// 起始值
        /// 结束值
        /// 
        public static long SortedSetLengthByValue(int dbIndex, string key, T startValue, T endValue)
        {
            var db = Instance.GetDatabase(dbIndex);
            var sValue = ConvertJson(startValue);
            var eValue = ConvertJson(endValue);
            return db.SortedSetLengthByValue(key, sValue, eValue);
        }

        /// 
        /// 获取指定Key的排序Score值
        /// 
        /// 
        /// 数据库
        /// 
        /// 
        /// 
        public static double? SortedSetScore(int dbIndex, string key, T value)
        {
            var db = Instance.GetDatabase(dbIndex);
            var rValue = ConvertJson(value);
            return db.SortedSetScore(key, rValue);
        }

        /// 
        /// 获取指定Key中最小Score值
        /// 
        /// 数据库
        /// 
        /// 
        public static double SortedSetMinScore(int dbIndex, string key)
        {
            var db = Instance.GetDatabase(dbIndex);
            double dValue = 0;
            var rValue = db.SortedSetRangeByRankWithScores(key, 0, 0, Order.Ascending).FirstOrDefault();
            dValue = rValue != null ? rValue.Score : 0;
            return dValue;
        }

        /// 
        /// 获取指定Key中最大Score值
        /// 
        /// 数据库
        /// 
        /// 
        public static double SortedSetMaxScore(int dbIndex, string key)
        {
            var db = Instance.GetDatabase(dbIndex);
            double dValue = 0;
            var rValue = db.SortedSetRangeByRankWithScores(key, 0, 0, Order.Descending).FirstOrDefault();
            dValue = rValue != null ? rValue.Score : 0;
            return dValue;
        }

        /// 
        /// 删除Key中指定的值
        /// 
        /// 数据库
        /// 
        /// 
        public static long SortedSetRemove(int dbIndex, string key, params T[] value)
        {
            var db = Instance.GetDatabase(dbIndex);
            var rValue = ConvertRedisValue(value);
            return db.SortedSetRemove(key, rValue);
        }

        /// 
        /// 删除指定起始值到结束值的数据
        /// 
        /// 
        /// 数据库
        /// 
        /// 起始值
        /// 结束值
        /// 
        public static long SortedSetRemoveRangeByValue(int dbIndex, string key, T startValue, T endValue)
        {
            var db = Instance.GetDatabase(dbIndex);
            var sValue = ConvertJson(startValue);
            var eValue = ConvertJson(endValue);
            return db.SortedSetRemoveRangeByValue(key, sValue, eValue);
        }

        /// 
        /// 删除 从 start 开始的 stop 条数据
        /// 
        /// 数据库
        /// 
        /// 
        /// 
        /// 
        public static long SortedSetRemoveRangeByRank(int dbIndex, string key, long start, long stop)
        {
            var db = Instance.GetDatabase(dbIndex);
            return db.SortedSetRemoveRangeByRank(key, start, stop);
        }

        /// 
        /// 根据排序分数Score，删除从 start 开始的 stop 条数据
        /// 
        /// 数据库
        /// 
        /// 
        /// 
        /// 
        public static long SortedSetRemoveRangeByScore(int dbIndex, string key, double start, double stop)
        {
            var db = Instance.GetDatabase(dbIndex);
            return db.SortedSetRemoveRangeByScore(key, start, stop);
        }

        /// 
        /// 获取从 start 开始的 stop 条数据
        /// 
        /// 
        /// 数据库
        /// 
        /// 起始数
        /// -1表示到结束，0为1条
        /// 是否按降序排列
        /// 
        public static List SortedSetRangeByRank(int dbIndex, string key, long start = 0, long stop = -1, bool desc = false)
        {
            var db = Instance.GetDatabase(dbIndex);
            Order orderBy = desc ? Order.Descending : Order.Ascending;
            var rValue = db.SortedSetRangeByRank(key, start, stop, orderBy);
            return ConvetList(rValue);
        }
        #endregion

        #region 异步方法

        /// 
        /// 添加一个值到Key
        /// 
        /// 
        ///  数据库
        /// 
        /// 
        /// 排序分数，为空将获取集合中最大score加1
        /// 
        public static async Task<bool> SortedSetAddAsync(int dbIndex, string key, T value, double? score = null)
        {
            var db = Instance.GetDatabase(dbIndex);
            double scoreNum = score ?? _GetScore(key, db);
            return await db.SortedSetAddAsync(key, ConvertJson(value), scoreNum);
        }

        /// 
        /// 添加一个集合到Key
        /// 
        /// 
        ///  数据库
        /// 
        /// 
        /// 排序分数，为空将获取集合中最大score加1
        /// 
        public static async Task<long> SortedSetAddAsync(int dbIndex, string key, List value, double? score = null)
        {
            var db = Instance.GetDatabase(dbIndex);
            double scoreNum = score ?? _GetScore(key, db);
            SortedSetEntry[] rValue = value.Select(o => new SortedSetEntry(ConvertJson(o), scoreNum++)).ToArray();
            return await db.SortedSetAddAsync(key, rValue);
        }

        /// 
        /// 获取集合中的数量
        /// 
        ///  数据库
        /// 
        /// 
        public static async Task<long> SortedSetLengthAsync(int dbIndex, string key)
        {
            var db = Instance.GetDatabase(dbIndex);
            return await db.SortedSetLengthAsync(key);
        }

        /// 
        /// 获取指定起始值到结束值的集合数量
        /// 
        /// 
        /// 数据库
        /// 
        /// 起始值
        /// 结束值
        /// 
        public static async Task<long> SortedSetLengthByValueAsync(int dbIndex, string key, T startValue, T endValue)
        {
            var db = Instance.GetDatabase(dbIndex);
            var sValue = ConvertJson(startValue);
            var eValue = ConvertJson(endValue);
            return await db.SortedSetLengthByValueAsync(key, sValue, eValue);
        }

        /// 
        /// 获取指定Key中最大Score值
        /// 
        /// 数据库
        /// 
        /// 
        public static async Task<double> SortedSetMaxScoreAsync(int dbIndex, string key)
        {
            var db = Instance.GetDatabase(dbIndex);
            double dValue = 0;
            var rValue = (await db.SortedSetRangeByRankWithScoresAsync(key, 0, 0, Order.Descending)).FirstOrDefault();
            dValue = rValue != null ? rValue.Score : 0;
            return dValue;
        }

        /// 
        /// 删除Key中指定的值
        /// 
        /// 数据库
        /// 
        /// 
        public static async Task<long> SortedSetRemoveAsync(int dbIndex, string key, params T[] value)
        {
            var db = Instance.GetDatabase(dbIndex);
            var rValue = ConvertRedisValue(value);
            return await db.SortedSetRemoveAsync(key, rValue);
        }

        /// 
        /// 删除指定起始值到结束值的数据
        /// 
        /// 
        /// 数据库
        /// 
        /// 起始值
        /// 结束值
        /// 
        public static async Task<long> SortedSetRemoveRangeByValueAsync(int dbIndex, string key, T startValue, T endValue)
        {
            var db = Instance.GetDatabase(dbIndex);
            var sValue = ConvertJson(startValue);
            var eValue = ConvertJson(endValue);
            return await db.SortedSetRemoveRangeByValueAsync(key, sValue, eValue);
        }

        /// 
        /// 删除 从 start 开始的 stop 条数据
        /// 
        /// 数据库
        /// 
        /// 
        /// 
        /// 
        public static async Task<long> SortedSetRemoveRangeByRankAsync(int dbIndex, string key, long start, long stop)
        {
            var db = Instance.GetDatabase(dbIndex);
            return await db.SortedSetRemoveRangeByRankAsync(key, start, stop);
        }

        #endregion

        #region private method
        /// 
        /// 获取几个集合的交叉并集合,并保存到一个新Key中
        /// 
        /// 
        /// Union：并集  Intersect：交集  Difference：差集  详见 
        /// 保存的新Key名称
        /// 要操作的Key集合
        /// 
        private static long _SortedSetCombineAndStore(IDatabase db, SetOperation operation, string destination, params string[] keys)
        {
            RedisKey[] keyList = ConvertRedisKeysAddSysCustomKey(keys);
            var rValue = db.SortedSetCombineAndStore(operation, destination, keyList);
            return rValue;

        }

        /// 
        /// 将string类型的Key转换成  型的Key，并添加前缀字符串
        /// 
        /// 
        /// 
        private static RedisKey[] ConvertRedisKeysAddSysCustomKey(params string[] redisKeys) => redisKeys.Select(redisKey => (RedisKey)redisKey).ToArray();

        /// 
        /// 获取指定Key中最大Score值,
        /// 
        /// key名称，注意要先添加上Key前缀
        /// 
        private static double _GetScore(string key, IDatabase db)
        {
            double dValue = 0;
            var rValue = db.SortedSetRangeByRankWithScores(key, 0, 0, Order.Descending).FirstOrDefault();
            dValue = rValue != null ? rValue.Score : 0;
            return dValue + 1;
        }
        #endregion

        #endregion

        #region SET

        /// 
        ///   Add the specified member to the set stored at key. Specified members that are  already a member of this set are ignored. If key does not exist, a new set is created before adding the specified members.
        /// 
        /// 
        /// 
        /// 
        /// 
        public static bool SetAdd(int dbIndex, string key, T value)
        {
            var db = Instance.GetDatabase(dbIndex);
            return db.SetAdd(key, ConvertJson(value));
        }

        /// 
        ///   Add the specified member to the set stored at key. Specified members that are  already a member of this set are ignored. If key does not exist, a new set is created before adding the specified members.
        /// 
        /// 
        /// 
        /// 
        /// 
        public static async Task<bool> SetAddAsync(int dbIndex, string key, T value)
        {
            var db = Instance.GetDatabase(dbIndex);
            return await db.SetAddAsync(key, ConvertJson(value));
        }

        /// 
        /// Returns the members of the set resulting from the specified operation against the given sets.
        /// 
        /// 
        /// 
        /// 
        /// 
        /// 
        /// 
        public static string[] SetCombine(int dbIndex, SetOperation operation, string firstKey, string secondKey)
        {
            var db = Instance.GetDatabase(dbIndex);
            var array = db.SetCombine(operation, firstKey, secondKey); 
            return array.ToStringArray();
        }

        /// 
        /// Returns the members of the set resulting from the specified operation against the given sets.
        /// 
        /// 
        /// 
        /// 
        /// 
        /// 
        /// 
        public static async Task<string[]> SetCombineAsync(int dbIndex, SetOperation operation, string firstKey, string secondKey)
        {
            var db = Instance.GetDatabase(dbIndex);
            var array = await db.SetCombineAsync(operation, firstKey, secondKey);
            return array.ToStringArray();
        }

        /// 
        /// Returns if member is a member of the set stored at key.
        /// 
        /// 
        /// 
        /// 
        /// Returns if member is a member of the set stored at key.
        public static bool SetContains(int dbIndex, string key, T value)
        {
            var db = Instance.GetDatabase(dbIndex);
            return db.SetContains(key, ConvertJson(value));
        }

        /// 
        /// Returns if member is a member of the set stored at key.
        /// 
        /// 
        /// 
        /// 
        /// Returns if member is a member of the set stored at key.
        public static async Task<bool> SetContainsAsync(int dbIndex, string key, T value)
        {
            var db = Instance.GetDatabase(dbIndex);
            return await db.SetContainsAsync(key, ConvertJson(value));
        }

        /// 
        /// 返回对应键值集合的长度|Returns the set cardinality (number of elements) of the set stored at key.
        /// 
        /// 
        /// 
        /// 
        public static long SetLength(int dbIndex, string key)
        {
            var db = Instance.GetDatabase(dbIndex);
            return db.SetLength(key);
        }

        /// 
        /// 返回对应键值集合的长度|Returns the set cardinality (number of elements) of the set stored at key.
        /// 
        /// 
        /// 
        /// 
        public static async Task<long> SetLengthAsync(int dbIndex, string key)
        {
            var db = Instance.GetDatabase(dbIndex);
            return await db.SetLengthAsync(key);
        }

        /// 
        /// 返回存储在键的集合值的所有成员|Returns all the members of the set value stored at key.
        /// 
        /// 
        /// 
        /// 
        public static List SetMembers(int dbIndex, string key)
        {
            var db = Instance.GetDatabase(dbIndex);
            var array = db.SetMembers(key);
            return ConvetList(array);
        }

        /// 
        /// 返回存储在键的集合值的所有成员|Returns all the members of the set value stored at key.
        /// 
        /// 
        /// 
        /// 
        public static async Task> SetMembersAsync(int dbIndex, string key)
        {
            var db = Instance.GetDatabase(dbIndex);
            var array = await db.SetMembersAsync(key);
            return ConvetList(array);
        }

        /// 
        /// Move member from the set at source to the set at destination. This operation is atomic. In every given moment the element will appear to be a member of source or destination for other clients. When the specified element already exists in the destination set, it is only removed from the source set.
        /// 
        /// 
        /// 
        /// 
        /// 
        /// 
        public static bool SetMove(int dbIndex, string sourceKey, string destinationKey, T value)
        {
            var db = Instance.GetDatabase(dbIndex);
            return db.SetMove(sourceKey, destinationKey, ConvertJson(value));
        }

        /// 
        /// Move member from the set at source to the set at destination. This operation is atomic. In every given moment the element will appear to be a member of source or destination for other clients. When the specified element already exists in the destination set, it is only removed from the source set.
        /// 
        /// 
        /// 
        /// 
        /// 
        /// 
        public static async Task<bool> SetMoveAsync(int dbIndex, string sourceKey, string destinationKey, T value)
        {
            var db = Instance.GetDatabase(dbIndex);
            return await db.SetMoveAsync(sourceKey, destinationKey, ConvertJson(value));
        }

        /// 
        /// Removes and returns a random element from the set value stored at key.
        /// 
        /// 
        /// 
        /// 
        public static T SetPop(int dbIndex, string key)
        {
            var db = Instance.GetDatabase(dbIndex);
            var value = db.SetPop(key);
            return ConvertObj(value);
        }

        /// 
        /// Removes and returns a random element from the set value stored at key.
        /// 
        /// 
        /// 
        /// 
        public static async Task SetPopAsync(int dbIndex, string key)
        {
            var db = Instance.GetDatabase(dbIndex);
            var value = await db.SetPopAsync(key);
            return ConvertObj(value);
        }

        /// 
        /// Return a random element from the set value stored at key.
        /// 
        /// 
        /// 
        /// 
        public static T SetRandomMember(int dbIndex, string key)
        {
            var db = Instance.GetDatabase(dbIndex);
            var value = db.SetRandomMember(key);
            return ConvertObj(value);
        }

        /// 
        /// Return a random element from the set value stored at key.
        /// 
        /// 
        /// 
        /// 
        public static async Task SetRandomMemberAsync(int dbIndex, string key)
        {
            var db = Instance.GetDatabase(dbIndex); 
            var value = await db.SetRandomMemberAsync(key);
            return ConvertObj(value);
        }

        /// 
        /// Return an array of count distinct elements if count is positive. If called with a negative count the behavior changes and the command is allowed to return the same element multiple times. In this case the numer of returned elements is the absolute value of the specified count.
        /// 
        /// 
        /// 
        /// 
        /// 
        public static string[] SetRandomMember(int dbIndex, string key, long count)
        {
            var db = Instance.GetDatabase(dbIndex);
            return db.SetRandomMembers(key, count).ToStringArray();
        }

        /// 
        /// Return an array of count distinct elements if count is positive. If called with a negative count the behavior changes and the command is allowed to return the same element multiple times. In this case the numer of returned elements is the absolute value of the specified count.
        /// 
        /// 
        /// 
        /// 
        /// 
        public static async Task<string[]> SetRandomMembersAsync(int dbIndex, string key, long count)
        {
            var db = Instance.GetDatabase(dbIndex);
            var array = await db.SetRandomMembersAsync(key, count);
            return array.ToStringArray();
        }

        /// 
        /// Remove the specified member from the set stored at key. Specified members that  are not a member of this set are ignored.
        /// 
        /// 
        /// 
        /// 
        public static bool SetRemove(int dbIndex, string key, string value)
        {
            var db = Instance.GetDatabase(dbIndex);
            return db.SetRemove(key, value);
        }

        /// 
        /// Remove the specified member from the set stored at key. Specified members that  are not a member of this set are ignored.
        /// 
        /// 
        /// 
        /// 
        public static async Task<bool> SetRemoveAsync(int dbIndex, string key, string value)
        {
            var db = Instance.GetDatabase(dbIndex);
            return await db.SetRemoveAsync(key, value);
        }

        /// 
        /// The SSCAN command is used to incrementally iterate over set; note: to resume an iteration via cursor, cast the original enumerable or enumerator to IScanningCursor.
        /// 
        /// 
        /// 
        /// 
        public static IEnumerable SetScan(int dbIndex, string key)
        {
           return Instance.GetDatabase(dbIndex).SetScan(key);
        }
        #endregion

        #region  当作消息代理中间件使用 一般使用更专业的消息队列来处理这种业务场景
        /// 
        /// 当作消息代理中间件使用
        /// 消息组建中,重要的概念便是生产者,消费者,消息中间件。
        /// 
        /// 
        /// 
        /// 
        public static long Publish(string channel, string message)
        {
            ISubscriber sub = Instance.GetSubscriber();
            //return sub.Publish("messages", "hello");
            return sub.Publish(channel, message);
        }

        /// 
        /// 在消费者端得到该消息并输出
        /// 
        /// 
        /// 
        public static void Subscribe(string channelFrom)
        {
            ISubscriber sub = Instance.GetSubscriber();
            sub.Subscribe(channelFrom, (channel, message) =>
            {
                Console.WriteLine((string)message);
            });
        }
        #endregion

        #region EventHandler
        /// 
        /// 连接失败 ， 如果重新连接成功你将不会收到这个通知
        /// 
        /// 
        /// 
        private static void MuxerConnectionFailed(object sender, ConnectionFailedEventArgs e)
        {

        }

        /// 
        /// 重新建立连接之前的错误
        /// 
        /// 
        /// 
        private static void MuxerConnectionRestored(object sender, ConnectionFailedEventArgs e)
        {

        }

        /// 
        /// 发生错误时
        /// 
        /// 
        /// 
        private static void MuxerErrorMessage(object sender, RedisErrorEventArgs e)
        {
        }

        /// 
        /// 更改集群
        /// 
        /// 
        /// 
        private static void MuxerHashSlotMoved(object sender, HashSlotMovedEventArgs e)
        {
            // LogHelper.WriteInfoLog("HashSlotMoved:NewEndPoint" + e.NewEndPoint + ", OldEndPoint" + e.OldEndPoint);
        }

        /// 
        /// redis类库错误
        /// 
        /// 
        /// 
        private static void MuxerInternalError(object sender, InternalErrorEventArgs e)
        {
        }
        #endregion

        #region 内部辅助方法

        /// 
        /// 将对象转换成string字符串
        /// 
        /// 
        /// 
        /// 
        public static string ConvertJson(T value)
        {
            string result = value is string ? value.ToString() :
                JsonConvert.SerializeObject(value, Formatting.None);
            return result;
        }
       
        /// 
        /// 将值集合转换成RedisValue集合
        /// 
        /// 
        /// 
        /// 
        private static RedisValue[] ConvertRedisValue(params T[] redisValues) => redisValues.Select(o => (RedisValue)ConvertJson(o)).ToArray();

        /// 
        /// 将值反系列化成对象集合
        /// 
        /// 
        /// 
        /// 
        public static List ConvetList(RedisValue[] values)
        {
            List result = new List();
            foreach (var item in values)
            {
                var model = ConvertObj(item);
                result.Add(model);
            }
            return result;
        }

        /// 
        /// 将值反系列化成对象
        /// 
        /// 
        /// 
        /// 
        public static T ConvertObj(RedisValue value)
        {
            return value.IsNullOrEmpty ? default(T) : JsonConvert.DeserializeObject(value);
        }

       

        #endregion
    }
}

View Code

在以上RedisUtils帮助类的基础上封装一次调用：

 /// 
    /// Redis帮助类
    /// 
    public class RedisHelper
    {
        /// 
        /// 缓存失效时长
        /// 
        public const int EXPIRY = 30;

        private static int CheckDbIndex(int dbIndex)
        {
            if (dbIndex > 16 || dbIndex < 0)
            {
                dbIndex = 0;
            }
            return dbIndex;
        }

        /// 
        /// 获取缓存数据
        /// 
        /// 
        /// Redis数据库索引
        /// Redis键
        /// 从其他地方获取数据源，并缓存到Redis中
        /// 过期时间，单位：分钟
        /// 
        public static T GetObject(int dbIndex, string key, Func fun, int? timeout = EXPIRY) where T : class
        {
            dbIndex = CheckDbIndex(dbIndex);
            T data = RedisUtils.StringGet(dbIndex, key);
            if (data != null)
            {
                return data;
            }
            if (fun != null)
            {
                data = fun();
            }
            if (data != null)
            {
                TimeSpan? timeSp = null;
                if (timeout != null)
                    timeSp = TimeSpan.FromMinutes(Convert.ToDouble(timeout));
                RedisUtils.StringSet(dbIndex, key, data, timeSp);
            }
            return data;
        }

        /// 
        /// KV
        /// 
        /// 
        /// 库
        /// 键
        /// 如找不到则从func获取
        /// 超时时间
        /// 
        public static T GetObject_KV(int dbIndex, string key, Func func, TimeSpan? timeout) where T : class
        {
            T data = RedisUtils.StringGet(dbIndex, key);
            if (data != null)
            {
                return data;
            }
            if (func != null)
            {
                data = func();
            }
            if (data != null)
            {
                RedisUtils.StringSet(dbIndex, key, data, timeout);
            }
            return data;
        }

        /// 
        /// 异步获取缓存数据
        /// 
        /// 数据集类型
        /// 数据库
        /// 键
        /// 从其他地方获取数据源，并缓存到Redis中
        /// 过期时间，单位：分钟
        /// 
        public static async Task GetObjectAsync(int dbIndex, string key, Func fun, int timeout = EXPIRY) where T : class
        {
            dbIndex = CheckDbIndex(dbIndex);
            T data = RedisUtils.StringGet(dbIndex, key);
            if (data != null)
            {
                return data;
            }

            if (fun != null)
            {
                data = await Task.Run(() =>
                {
                    return fun();
                });
            }
            if (data != null)
            {
                RedisUtils.StringSet(dbIndex, key, data, TimeSpan.FromMinutes(timeout));
            }
            return data;
        }

        /// 
        /// 异步获取缓存数据
        /// 
        /// 数据集类型
        /// 数据库
        /// 键
        /// 从其他地方获取数据源，并缓存到Redis中
        /// 过期时间，单位：分钟
        /// 
        public static async Task GetObjectAsync(int dbIndex, string key, Func> fun, int timeout = EXPIRY) where T : class
        {
            dbIndex = CheckDbIndex(dbIndex);
            RedisCache cache = new RedisCache();
            cache.CacheData = RedisUtils.StringGet(dbIndex, key);
            if (cache.CacheData != null)
            {
                return cache.CacheData;
            }

            var temp = await Task.Run(() =>
            {
                return fun();
            });

            if (temp != null) cache = temp;

            if (cache.UseCache)
            {
                RedisUtils.StringSet(dbIndex, key, cache.CacheData, TimeSpan.FromMinutes(timeout));
            }
            return cache.CacheData;
        }

        /// 
        /// 异步获取数据集合
        /// 
        /// 数据集类型
        /// 数据库
        /// 键
        /// 从其他地方获取数据源，并缓存到Redis中
        /// 过期时间，单位：分钟
        /// 
        public static async Task> GetListAsync(int dbIndex, string key, Func> fun, int timeout = EXPIRY) where T : class
        {
            dbIndex = CheckDbIndex(dbIndex);
            List datas = RedisUtils.StringGet>(dbIndex, key);
            if (datas != null && datas.Count > 0)
            {
                return datas;
            }

            datas = await Task.Run(() =>
            {
                return fun();
            });

            if (datas != null && datas.Count > 0)
            {
                RedisUtils.StringSet>(dbIndex, key, datas, TimeSpan.FromMinutes(timeout));
            }
            return datas;
        }

        /// 
        /// ZSet
        /// 
        /// 
        /// 库
        /// 键
        /// 如找不到则从func获取
        /// 
        public static List GetObject_ZSet(int dbIndex, string key, Func> func) where T : class
        {
            List data = RedisUtils.SortedSetRangeByRank(dbIndex, key);
            if (data != null && data.Count > 0)
            {
                return data;
            }
            if (func != null)
            {
                data = func();
            }
            if (data != null)
            {
                RedisUtils.SortedSetAdd(dbIndex, key, data);
            }
            return data;
        }


        /// 
        /// Hash
        /// 
        /// 
        /// 库
        /// hashID
        /// 键
        /// 如找不到则从func获取
        /// 
        public static T GetObject_Hash(int dbIndex, string hashID, string key, Func func) where T : class
        {
            T data = RedisUtils.HashGet(dbIndex, hashID, key);
            if (data != null)
            {
                return data;
            }
            if (func != null)
            {
                data = func();
            }
            if (data != null)
            {
                RedisUtils.HashSet(dbIndex, hashID, key, data);
            }
            return data;
        }
    }

修复

经过反复阅读源码和测试，还有得到源作者NickCraver的指导，ConnectionMultiplexer是线程安全的，在多线程的情况下，避免使用lock来作为单例来使用，出现的连接超时的情况。

It was not possible to connect to the redis server(s).ConnectTimeout

正确姿势在帮助类折叠代码里面。

测试源码：

static void TestRedis()
        {
            int dbIdx = 4;
            string key = "testKey";
            Task.Run(()=> {
                while (true)
                {
                    Task.Run(() =>
                    {
                        RedisUtils.StringSet(dbIdx, key, DateTime.Now.ToString(), TimeSpan.FromSeconds(30));
                    });
                    Task.Run(() =>
                    {
                        string v = RedisUtils.StringGet(dbIdx, key);
                        Console.WriteLine("1：" + v);
                    });
                    System.Threading.Thread.Sleep(100);
                }
            });
            Task.Run(() => {
                while (true)
                {
                    Task.Run(() =>
                    {
                        RedisUtils.StringSet(dbIdx, key, DateTime.Now.ToString(), TimeSpan.FromSeconds(30));
                    });
                    Task.Run(() =>
                    {
                        string v = RedisUtils.StringGet(dbIdx, key);
                        Console.WriteLine("2：" + v);
                    });
                    System.Threading.Thread.Sleep(100);
                }
            });
            Task.Run(() => {
                while (true)
                {
                    Task.Run(() =>
                    {
                        RedisUtils.StringSet(dbIdx, key, DateTime.Now.ToString(), TimeSpan.FromSeconds(30));
                    });
                    Task.Run(() =>
                    {
                        string v = RedisUtils.StringGet(dbIdx, key);
                        Console.WriteLine("3：" + v);
                    });
                    System.Threading.Thread.Sleep(100);
                }
            });

        }

View Code

已封装在这里?

转载于:https://www.cnblogs.com/EminemJK/p/8527498.html

你可能感兴趣的:(StackExchange.Redis 二次封装)

常用API---初始化，话题和服务对象创建，回旋/头函数，时间（如：获取当前时刻，持续时间执行频率，休眠，定时器等），运行频率，定时器，节点生命周期，日志相关API 李卓璐机器人人工智能 c++
初始化ROS节点ros::init(argc,argv,“name”,options);作用：ros初始化函数参数： 1.argc—封装实参的个数（n+1个->有一个是自身）； 2.argv—封装参数的数组； 3.name—为节点命名（唯一性）； 4.options—节点启动项，解决节点重名问题。返回值：void使用： 1.argc和argv的使用：如果按照ROS中的特定格式传入实参，那么RO
[高精度加法和乘法] 阶乘之和 StudyingPanda 算法
题目描述用高精度计算出S=1!+2!+3!+⋯+n!（n≤50）。其中!表示阶乘，定义为n!=n×(n−1)×(n−2)×⋯×1。例如，5!=5×4×3×2×1=120。输入格式一个正整数n。输出格式一个正整数S，表示计算结果。输入输出样例输入#13输出#19解题分析思路很简单，求出阶乘之后再累次求和即可，但是关键在于这个数据量实在是太大了，所以必须封装高精度运算，这里我们创建一个BigInt类，
static静态变量的简略解释及其练习 JS-JiMao java 开发语言
1.当static修饰一个变量时，说白了，就是让该变量的值不能改变，即第二次调用我们不能改变它的值，它的值在第一次就已经确定下来了packagewww.mmm;classStudent{privateStringname;privateintage;privateStringgender;publicstaticStringteachername;publicStudent(){}publicSt
java基础相关面试题详细总结。。。。。96 java 开发语言
1.Java中的数据类型有哪些？答：Java中的数据类型包括基本数据类型（如整数、浮点数、字符等）和引用数据类型（如类、接口、数组等）。2.什么是面向对象编程（OOP）？答：面向对象编程是一种编程范式，它将数据和对数据的操作封装在一起，形成对象。通过对象之间的交互来实现程序的功能。3.解释类和对象的关系。答：类是对象的抽象描述，而对象是类的具体实例。一个类可以创建多个对象，每个对象都具有类中定义的
DCGAN中的生成器和识别器代码详解 YYLin-AI DCGAN 深度学习 celeba tensorflow
#DCGAN中的生成器我自己写的有一个封装好的用于生成器和识别器的卷积操作但是在这个代码中我没有使用我自己的代码#原因想绍一下tensorflow自带的函数所以找了一个以前在书上的代码申明一下这个不是原创但是原来代码中有几处不符合DCGAN的要求所以就做了一些修改转载链接没有就直接写成原创建议看代码之前先看看DCGAN的特点，然后再看代码中如何实这些特点的这样会更有帮助DCGAN（深度卷积的对抗生
C#学习笔记 2301_79022588 学习笔记
一、事件派发器在C#中，事件派发器通常是指事件委托和事件处理程序的组合，用于实现一种观察者设计模式。它允许对象在状态发生变化时通知其他对象，从而实现对象之间的解耦。事件派发器的基本组成部分：事件委托（EventDelegate）：事件委托是一种特殊的委托，用于封装可以被调用的方法。它定义了事件的签名，即指定了事件处理程序方法的参数和返回类型。通常，事件委托声明在事件派发器类的外部，并且使用dele
爱情真的能永恒吗？作家雪漠
爱情真的能永恒吗？◈|作者：雪漠★一位哲学家曾说：“人不能两次踏入同一条河流。”为什么这么说呢？因为当你第二次踏入某条河流的时候，它已经不是你第一次踏入的那条河了，河中不断流动的水早已发生了变化。同理，人也不能两次接触同一个人。因为，每时每刻，人身上的细胞都在发生着变化，想法、心念、心情、思维都在时时刻刻发生着变化。有些人老是埋怨自己的女朋友说话不算数，因为她老是食言，昨天答应的事，今天就变了，但
动态多态的注意事项 Austin_1024 动态多态静态多态虚函数子类重写父类虚函数实现动态多态
大家好：衷心希望各位点赞。您的问题请留在评论区，我会及时回答。多态的基本概念多态是C++面向对象三大特性之一（多态、继承、封装）多态分为两类：静态多态：函数重载和运算符重载属于静态多态，复用函数名。动态多态：通过派生类和虚函数实现运行时多态。静态多态和动态多态的区别：静态多态的函数地址早绑定——编译阶段确定函数地址。动态多态的函数地址晚绑定——运行阶段确定函数地址。下面通过案例讲解多态：#incl
opencv 十八 python下实现0缓存掉线重连的rtsp直播流播放器摸鱼的机器猫 opencv实战 opencv python 缓存
使用opencv打开rtsp视频流时，会因为网络问题导致VideoCapture掉线；也会因为图像的后处理阶段耗时过长导致opencv缓冲区数据堆积，从而使程序无法及时处理最新的数据。为此对cv2.VideoCapture进行封装，实现0缓存掉线重连的rtsp直播流播放器，让程序能一直处理最新的数据。代码实现fromcollectionsimportdequeimportthreadingimpo
计算机网络复试总结（五） interee 面试计算机网络
可能会问：基础知识问题：请简述TCP/IP协议栈的层次结构及其功能。TCP/IP协议栈的层次结构及其功能可以简要概述如下：层次结构：TCP/IP协议栈通常被划分为四个主要层次，从底层到高层分别是网络接口层（也称为链路层或数据链路层）、网络层（也称为网际网层）、传输层和应用层。这四个层次协同工作，实现数据的封装、传输和解析，从而完成网络通信任务。功能概述：网络接口层：这是TCP/IP协议栈的最底层，
从0开始学python第14.6节 pygame.sprite(上) 阿达老师
游戏开发最核心的就是碰撞检测了，子弹击中敌人、足球射进门、吃加血包这些都是通过碰撞检测完成的。我们这节课学习的sprite模块对pygame的碰撞做了初步封装，简化我们开发这些模块时的代码。在pygame里，sprite通常是一个二维的图片。比如一辆汽车、一个狐狸、一条小狗等。下面我们就来详细学习一下sprite模块。prite基础和碰撞检测让我们来看一个使用sprite的例子，这个例子展示了一个
金英沧州焦点解决初64中17，本周第二次、第三次约练，总第440次、第441次分享，坚持分享第187天守护甜心
第440次分享青春期顾左右而言他的女生，可以和她聊她的小说，也许是她杜撰的小说，但是可以从中看出她的投射。通过谈论小说中主人公的情感、经历、认知、感受，了解她，走进她的脉络。当了解的足够多了，情绪宣泄的差不多了，可以联系到现实生活中，再聊现实生活，她就不那么防御了，因为她觉得咨询师理解她，她感到安全。一个外表阳光帅气自立的女孩子，内心一片柔情似水，渴望爱情，渴望被呵护，却羞于说出口，当她能说出来，
go的Job Scheduling ~kiss~ go golang 开发语言后端
背景司内线上服务有很多异步脚本，大量冗余代码，管理很不方便急需一个美丽的框架，让代码变得美好包gogetgithub.com/go-co-op/gocron/v2介绍gocronisajobschedulingpackagewhichletsyourunGofunctionsatpre-determinedintervals.概念JobJob封装（encapsulates）一个“任务task”，它
数据库（一）：基本语法一从零开始的奋豆数据库 sql
数据库第二次作业姓名：~~~，学号：~~~，专业：~~~2.66书写SQL查询来获取以下结果:A.星期五的ChangeClose。SELECTChangeCloseFROMNDXWHERETDayOfWeek='Friday';B.星期五的最小、最大和平均ChangeClose。SELECTMIN(ChangeClose)asMinChangeClose,MAX(ChangeClose)asMax
js封装SDK 在VUE、小程序、公众号直接调用js调用后端接口（本文以vue项目为例）祝你今天也快乐 js vue javascript vue.js 小程序
1.封装一个js文件msgSdk.js注意：需要修改这个请求地址apiServiceAddress;(function(){if(window.msgSdk){return}varmsgSdk=(function(){varm_msgSdk=thisvarapiServiceAddress="http://172.12.14.5:8000"this.I_SendHTTPRequest=functi
GB28181 —— 4、C++编写GB28181设备端，完成将.h264文件读取转发至GB28181服务并可播放（附源码）信必诺 GB28181 GB28181 eXosip2 Qt h264
效果源码说明主要功能模拟设备端，完成注册、注销、心跳等，完成读取.h264文件实时转ps格式后封包rtp进行推送给服务端播放。源码/****@remark:ps头的封装,里面的具体数据的填写已经占位，可以参考标准*@param:pData[in]填充ps头数据的地址*s64Src[in]时间戳*@return:0success,othersfailed*/intgb28181_mak
C/C++中使用静态函数的好处是什么 kfjh c语言 c++
使用静态函数的好处主要体现在以下几个方面：文件作用域：静态函数只在声明它的文件内可见，这有助于隐藏实现细节，提高封装性。这意味着不同的开发者在编写各自的函数时，不必担心函数名冲突的问题，因为即使函数名相同，只要它们在不同的文件中并且是静态的，就不会互相干扰。无this指针：静态函数不依赖于类的实例，因此它们不能直接访问非静态成员变量和非静态成员函数。这使得静态函数更像是一个普通的函数，只是它们被定
UI Automator 常用 API 整理咖啡加剁椒② 软件测试 ui 功能测试软件测试自动化测试程序人生职场和发展
主要类：importandroid.support.test.uiautomator.UiDevice;作用：设备封装类，测试过程中获取设备信息和设备交互。importandroid.support.test.uiautomator.UiObject;作用：所有控件抽象，用于表示一个Android控件。importandroid.support.test.uiautomator.UiObjectN
React—— props校验（非typescript校验类型）水煮庄周鱼鱼 React react.js typescript javascript
非typescript环境下，当我们在封装组件的时候，接受props时传入的内容，需要做类型检测，那我们可以用props校验进行类型的检查。props校验允许在创建组件的时候，就约定props的格式、类型等实现步骤：导入prop-types包使用组件名.propTypes={}来给组件的props添加校验规则校验规则通过PropTypes对象来指定如果props想设置默认值，可以通过default
实例：NX二次开发使用链表进行拉伸功能（链表相关功能练习）白雪公主的后妈 ug二次开发 NX二次开发链表相关函数的应用
一、概述在进行批量操作时经常会利用链表进行存放相应特征的TAG值，以便后续操作，最常见的就是拉伸功能。这里我们以拉伸功能为例子进行说明。二、常用链表相关函数UF_MODL_create_list创建一个链表，并返回链表的头指针。UF_MODL_put_list_item插入元素到链表中，不检验对象是否重复，或者已经存在。UF_MODL_ask_list_count获取链表对象数量，从头开始遇到NU
C++ 友元腾扬集团驻吉吉国大使 c++开发语言
友元提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用。友元分为：友元函数和友元类1.友元函数问题：现在尝试去重载operator>同理。classDate{public:Date(intyear,intmonth,intday):_year(year),_month(month),_day(day){}//d1d1.operator>(istream&_
2024.3.22 ARM Carl余 arm开发单片机嵌入式硬件
实现三个按键的中断main.c：主函数初始化#include"key_inc.h"#include"uart4.h"//封装延时函数voiddelay(intms){inti,j;for(i=0;iIAR&0x3ff;switch(irqno){case99:puts("key1_intc");//清除GICD中断排队标志GICD->ICPENDR[3]|=(0X1FPR1|=(0X1ICPEND
记沙盘练习小组第二次课程心理师刘津伶
图片发自App运华日记第297篇（2018.9.25周二）记沙盘练习小组第二次课程外面下着飘泼大雨，依然没有阻挡住沙盘实操练习第一期小组成员第二次练习的脚步。课程开始前，每人分享了第一次沙盘练习的收获：有的说通过第一次沙盘发现了自己以前不曾看到的一面，重新认识了自己，看见了自己害怕恐惧的一面；有的说通过第一次沙盘情绪得到了释放，回去之后心里舒服很多；有的说没做沙盘之前陷在问题里，而通过沙盘将自己抽
飞桨科学计算套件PaddleScience skywalk8163 人工智能 paddlepaddle 人工智能飞桨
PaddleScience是一个基于深度学习框架PaddlePaddle开发的科学计算套件，利用深度神经网络的学习能力和PaddlePaddle框架的自动(高阶)微分机制，解决物理、化学、气象等领域的问题。支持物理机理驱动、数据驱动、数理融合三种求解方式，并提供了基础API和详尽文档供用户使用与二次开发。安装当然要先安装好飞桨PaddlePaddle，再安装PaddleSciencepipinst
第10讲_Spring对Dao的支持吴国友
Spring框架优秀就是在于MVC开发的时候一旦需要对底层的数据库操作，它可以很好的支持JDBC技术，还有现在主流的ORM框架（Hibernate,MyBatis）技术。重点先介绍Spring对JDBC支持。在Spring对JDBC支持中提供了一个模板JdbcTemplate，此模板封装了对JDBC操作的许多方法，且消除了忽视资源释放而引起的漏洞Spring对JDBC操作需要导入的jar（开发环境
2022第一场雪崔艳丽的成长
早上进单位门那一刻，门卫一边给量体温，一边说，只许进不许出。上午单位全员做了核酸。果然，中午没让回家。都在餐厅吃饭，餐厅里空前地爆满。下午下班被通知可以出院儿了，不过只许南院北院两点一线。晚上有考试，忙到9点半，回家。晚上叫了2个小伙来帮忙，发试卷袋和答题卡袋时，发现少了一个答题卡袋，我有点小慌了，我们赶紧找，一边找，我一边跟印刷厂联系，是不是少装了？让他们火速再印刷出来一份，封装好，一边联系离印
曾国藩（张宏杰著）第九章安庆这块难啃的骨头 day87 拿什么爱你
1．曾国藩的二次出山这次咸丰依然不给曾国藩实权，只是想拿他应急，胡林翼为曾国藩谋四川总督不得，加上曾国藩和胡林翼判断四川情况无需多虑，因此胡又请皇上让曾国藩和他一起进军安徽。此时，因为咸丰的瞎指挥，罗泽南的继任也是湘军最核心的精锐李继宾部在三河兵败阵亡。安徽全境情势不堪。咸丰最后同意曾国藩同胡林翼合军一处。2．和胡林翼联手攻占安庆曾胡两人意在取下安庆。安庆是长江边上的重镇，是南京的安全保障和粮饷供
chatgpt赋能python：Python编写一元二次方程公式 pythonxxoo ChatGpt chatgpt python 人工智能计算机
Python编写一元二次方程公式在数学中，一元二次方程是指形如ax2+bx+c=0ax^2+bx+c=0ax2+bx+c=0的方程，其中xxx为未知数，a,b,ca,b,ca,b,c为已知常数，且a≠0a\neq0a=0。本文将介绍如何使用Python编写一元二次方程的解法公式。介绍公式推导要求一元二次方程ax2+bx+c=0ax^2+bx+c=0ax2+bx+c=0的解，根据求根公式：x=−b
react可视化编辑器第五章升级版拖拽、缩放、转圈、移动 zhooson react.js 编辑器前端
本章代码结构：主入口Test.tsx,组件：ResizeControl.tsx本章花费俩天时间完成代码例子，单独抽离代码封装好一个ResizeControl组件，拿来即用。代码中constdomObj=document.getElementById(resize-item-${startPos.id})这句是关键代码，不然获取的dom节点有问题，导致多个红色div操作时候会重叠ResizeCont
Java二次开发海康SDK-对接门禁机一文全解半自定义大剑仙一文全解 java 前端服务器图像处理
写在最前SDK版本：CH-HCNetSDKV6.1.6.45_build20210302_win64参考文档：海康SDK使用手册_V6.1对接测试设备型号：DS-K1T671M设备序列号：E50247795业务目标使用门禁设备实现对人脸的抓拍，将抓拍的人脸与其对应的数据进行上传。业务流程图：业务流程节点解释：1.初始化SDK（NET_DVR_Init）：进行海康提供开发库的载入，使用海康官方提供的
[黑洞与暗粒子]没有光的世界 comsci
无论是相对论还是其它现代物理学,都显然有个缺陷,那就是必须有光才能够计算但是,我相信,在我们的世界和宇宙平面中,肯定存在没有光的世界.... 那么,在没有光的世界,光子和其它粒子的规律无法被应用和考察,那么以光速为核心的 &nbs
jQuery Lazy Load 图片延迟加载 aijuans jquery
基于 jQuery 的图片延迟加载插件，在用户滚动页面到图片之后才进行加载。对于有较多的图片的网页，使用图片延迟加载，能有效的提高页面加载速度。版本： jQuery v1.4.4+ jQuery Lazy Load v1.7.2 注意事项：需要真正实现图片延迟加载，必须将真实图片地址写在 data-original 属性中。若 src
使用Jodd的优点 Kai_Ge jodd
1. 简化和统一 controller ，抛弃 extends SimpleFormController ，统一使用 implements Controller 的方式。 2. 简化 JSP 页面的 bind, 不需要一个字段一个字段的绑定。 3. 对 bean 没有任何要求，可以使用任意的 bean 做为 formBean。使用方法简介
jpa Query转hibernate Query 120153216 Hibernate
public List<Map> getMapList(String hql, Map map) { org.hibernate.Query jpaQuery = entityManager.createQuery(hql); if (null != map) { for (String parameter : map.keySet()) { jp
Django_Python3添加MySQL/MariaDB支持 2002wmj mariaDB
现状首先，[email protected] 中默认的引擎为 django.db.backends.mysql 。但是在Python3中如果这样写的话，会发现 django.db.backends.mysql 依赖 MySQLdb[5] ，而 MySQLdb 又不兼容 Python3 于是要找一种新的方式来继续使用MySQL。 MySQL官方的方案首先据MySQL文档[3]说，自从MySQL
在SQLSERVER中查找消耗IO最多的SQL 357029540 SQL Server
返回做IO数目最多的50条语句以及它们的执行计划。 select top 50 (total_logical_reads/execution_count) as avg_logical_reads, (total_logical_writes/execution_count) as avg_logical_writes, (tot
spring UnChecked 异常官方定义！ 7454103 spring
如果你接触过spring的事物管理！那么你必须明白 spring的非捕获异常！即 unchecked 异常！因为 spring 默认这类异常事物自动回滚！！ public static boolean isCheckedException(Throwable ex) { return !(ex instanceof RuntimeExcep
mongoDB 入门指南、示例 adminjun java mongodb 操作
一、准备工作 1、下载mongoDB 下载地址：http://www.mongodb.org/downloads 选择合适你的版本相关文档：http://www.mongodb.org/display/DOCS/Tutorial 2、安装mongoDB A、不解压模式：将下载下来的mongoDB-xxx.zip打开，找到bin目录，运行mongod.exe就可以启动服务，默
CUDA 5 Release Candidate Now Available aijuans CUDA
The CUDA 5 Release Candidate is now available at http://developer.nvidia.com/<wbr></wbr>cuda/cuda-pre-production. Now applicable to a broader set of algorithms, CUDA 5 has advanced fe
Essential Studio for WinRT网格控件测评 Axiba JavaScript html5
Essential Studio for WinRT界面控件包含了商业平板应用程序开发中所需的所有控件，如市场上运行速度最快的grid 和chart、地图、RDL报表查看器、丰富的文本查看器及图表等等。同时，该控件还包含了一组独特的库，用于从WinRT应用程序中生成Excel、Word以及PDF格式的文件。此文将对其另外一个强大的控件——网格控件进行专门的测评详述。网格控件功能 1、
java 获取windows系统安装的证书或证书链 bewithme windows
有时需要获取windows系统安装的证书或证书链，比如说你要通过证书来创建java的密钥库。有关证书链的解释可以查看此处。 public static void main(String[] args) { SunMSCAPI providerMSCAPI = new SunMSCAPI(); S
NoSQL数据库之Redis数据库管理(set类型和zset类型) bijian1013 redis 数据库 NoSQL
4.sets类型 Set是集合，它是string类型的无序集合。set是通过hash table实现的，添加、删除和查找的复杂度都是O(1)。对集合我们可以取并集、交集、差集。通过这些操作我们可以实现sns中的好友推荐和blog的tag功能。 sadd：向名称为key的set中添加元
异常捕获何时用Exception，何时用Throwable bingyingao
用Exception的情况 try { //可能发生空指针、数组溢出等异常 } catch (Exception e) {
【Kafka四】Kakfa伪分布式安装 bit1129 kafka
在http://bit1129.iteye.com/blog/2174791一文中，实现了单Kafka服务器的安装，在Kafka中，每个Kafka服务器称为一个broker。本文简单介绍下，在单机环境下Kafka的伪分布式安装和测试验证 1. 安装步骤 Kafka伪分布式安装的思路跟Zookeeper的伪分布式安装思路完全一样，不过比Zookeeper稍微简单些(不
Project Euler bookjovi haskell
Project Euler是个数学问题求解网站，网站设计的很有意思，有很多problem，在未提交正确答案前不能查看problem的overview，也不能查看关于problem的discussion thread，只能看到现在problem已经被多少人解决了，人数越多往往代表问题越容易。看看problem 1吧： Add all the natural num
Java-Collections Framework学习与总结-ArrayDeque BrokenDreams Collections
表、栈和队列是三种基本的数据结构，前面总结的ArrayList和LinkedList可以作为任意一种数据结构来使用，当然由于实现方式的不同，操作的效率也会不同。这篇要看一下java.util.ArrayDeque。从命名上看
读《研磨设计模式》-代码笔记-装饰模式-Decorator bylijinnan java 设计模式
声明：本文只为方便我个人查阅和理解，详细的分析以及源代码请移步原作者的博客http://chjavach.iteye.com/ import java.io.BufferedOutputStream; import java.io.DataOutputStream; import java.io.FileOutputStream; import java.io.Fi
Maven学习(一) chenyu19891124 Maven私服
学习一门技术和工具总得花费一段时间，5月底6月初自己学习了一些工具，maven+Hudson+nexus的搭建，对于maven以前只是听说，顺便再自己的电脑上搭建了一个maven环境，但是完全不了解maven这一强大的构建工具，还有ant也是一个构建工具，但ant就没有maven那么的简单方便，其实简单点说maven是一个运用命令行就能完成构建，测试，打包，发布一系列功
[原创]JWFD工作流引擎设计----节点匹配搜索算法(用于初步解决条件异步汇聚问题) 补充 comsci 算法工作 PHP 搜索引擎嵌入式
本文主要介绍在JWFD工作流引擎设计中遇到的一个实际问题的解决方案，请参考我的博文"带条件选择的并行汇聚路由问题"中图例A2描述的情况(http://comsci.iteye.com/blog/339756),我现在把我对图例A2的一个解决方案公布出来，请大家多指点节点匹配搜索算法(用于解决标准对称流程图条件汇聚点运行控制参数的算法) 需要解决的问题：已知分支
Linux中用shell获取昨天、明天或多天前的日期 daizj linux shell 上几年昨天获取上几个月
在Linux中可以通过date命令获取昨天、明天、上个月、下个月、上一年和下一年 # 获取昨天 date -d 'yesterday' # 或 date -d 'last day' # 获取明天 date -d 'tomorrow' # 或 date -d 'next day' # 获取上个月 date -d 'last month' #
我所理解的云计算 dongwei_6688 云计算
在刚开始接触到一个概念时，人们往往都会去探寻这个概念的含义，以达到对其有一个感性的认知，在Wikipedia上关于“云计算”是这么定义的，它说： Cloud computing is a phrase used to describe a variety of computing co
YII CMenu配置 dcj3sjt126com yii
Adding id and class names to CMenu We use the id and htmlOptions to accomplish this. Watch. //in your view $this->widget('zii.widgets.CMenu', array( 'id'=>'myMenu', 'items'=>$this-&g
设计模式之静态代理与动态代理 come_for_dream 设计模式
静态代理与动态代理代理模式是java开发中用到的相对比较多的设计模式，其中的思想就是主业务和相关业务分离。所谓的代理设计就是指由一个代理主题来操作真实主题，真实主题执行具体的业务操作，而代理主题负责其他相关业务的处理。比如我们在进行删除操作的时候需要检验一下用户是否登陆，我们可以删除看成主业务，而把检验用户是否登陆看成其相关业务
【转】理解Javascript 系列 gcc2ge JavaScript
理解Javascript_13_执行模型详解摘要: 在《理解Javascript_12_执行模型浅析》一文中,我们初步的了解了执行上下文与作用域的概念，那么这一篇将深入分析执行上下文的构建过程，了解执行上下文、函数对象、作用域三者之间的关系。函数执行环境简单的代码:当调用say方法时，第一步是创建其执行环境，在创建执行环境的过程中，会按照定义的先后顺序完成一系列操作:1.首先会创建一个
Subsets II hcx2013 set
Given a collection of integers that might contain duplicates, nums, return all possible subsets. Note: Elements in a subset must be in non-descending order. The solution set must not conta
Spring4.1新特性——Spring缓存框架增强 jinnianshilongnian spring4
目录 Spring4.1新特性——综述 Spring4.1新特性——Spring核心部分及其他 Spring4.1新特性——Spring缓存框架增强 Spring4.1新特性——异步调用和事件机制的异常处理 Spring4.1新特性——数据库集成测试脚本初始化 Spring4.1新特性——Spring MVC增强 Spring4.1新特性——页面自动化测试框架Spring MVC T
shell嵌套expect执行命令 liyonghui160com
一直都想把expect的操作写到bash脚本里,这样就不用我再写两个脚本来执行了,搞了一下午终于有点小成就,给大家看看吧. 系统:centos 5.x 1.先安装expect yum -y install expect 2.脚本内容: cat auto_svn.sh #!/bin/bash
Linux实用命令整理 pda158 linux
0. 基本命令　　linux 基本命令整理　　1. 压缩解压　　tar -zcvf a.tar.gz a #把a压缩成a.tar.gz 　　tar -zxvf a.tar.gz #把a.tar.gz解压成a 　　2. vim小结　　2.1 vim替换　　:m,ns/word_1/word_2/gc
独立开发人员通向成功的29个小贴士 shoothao 独立开发
概述：本文收集了关于独立开发人员通向成功需要注意的一些东西,对于具体的每个贴士的注解有兴趣的朋友可以查看下面标注的原文地址。明白你从事独立开发的原因和目的。保持坚持制定计划的好习惯。万事开头难，第一份订单是关键。培养多元化业务技能。提供卓越的服务和品质。谨小慎微。营销是必备技能。学会组织，有条理的工作才是最有效率的。 “独立
JAVA中堆栈和内存分配原理 uule java
1、栈、堆 1.寄存器：最快的存储区, 由编译器根据需求进行分配,我们在程序中无法控制.2. 栈：存放基本类型的变量数据和对象的引用，但对象本身不存放在栈中，而是存放在堆（new 出来的对象）或者常量池中（字符串常量对象存放在常量池中。）3. 堆：存放所有new出来的对象。4. 静态域：存放静态成员（static定义的）5. 常量池：存放字符串常量和基本类型常量（public static f