C#编程之功能比较全的StackExchange.Redis封装帮助类(.Net/C#)
小标 2018-09-17 来源 : 阅读 8505 评论 0

摘要:本文主要向大家介绍了C#编程之功能比较全的StackExchange.Redis封装帮助类(.Net/C#),通过具体的内容向大家展示,希望对大家学习C#编程有所帮助。

本文主要向大家介绍了C#编程之功能比较全的StackExchange.Redis封装帮助类(.Net/C#),通过具体的内容向大家展示,希望对大家学习C#编程有所帮助。

Redis官网https://redis.io/
以下内容未全部验证,如有问题请指出

 //static NewtonsoftSerializer serializer = new NewtonsoftSerializer();
        //static StackExchangeRedisCacheClient cacheClient = new StackExchangeRedisCacheClient(serializer);
        //private static IDatabase db = cacheClient.Database;

        private static string connstr = System.Configuration.ConfigurationManager.AppSettings["redisCacheClient"];// "127.0.0.1:6379,allowadmin=true";
        private static ConnectionMultiplexer conn = ConnectionMultiplexer.Connect(connstr);
        private static IDatabase db =  conn.GetDatabase(1);


        /// 


        /// 获取系统的redis key前缀
        /// 


        /// 

资源Id
        /// 


        public static string GetMyKey(string resourceid = "")
        {
           
            string Key = "report_";
            if (!string.IsNullOrWhiteSpace(resourceid))
            {
                Key = string.Format("report_res_{0}", resourceid);
            }
            return Key;
        }

        #region String 可以设置过期时间 同步

        /// 


        /// 保存单个key value
        /// 


        /// 

Redis Key
        /// 

保存的值
        /// 

过期时间
        /// 


        public static bool SetStringKey(string key, string value, TimeSpan? expiry = default(TimeSpan?))
        {
           
            return db.StringSet(key, value, expiry);
        }

        /// 


        /// 保存多个key value
        /// 


        /// 

key
        /// 


        public static bool SetStringKey(KeyValuePair

[] arr)
        {
            return db.StringSet(arr);
        }

        /// 
        /// 保存一个对象
        /// 

        /// 
        /// 
        /// 
        /// 
        public static bool SetStringKey(string key, T obj, TimeSpan? expiry = default(TimeSpan?))
        {
            string json = JsonConvert.SerializeObject(obj);
            return db.StringSet(key, json, expiry);
        }

        /// 
        /// 获取单个key的值
        /// 

        /// Redis Key
        /// 

        public static RedisValue GetStringKey(string key)
        {
            return db.StringGet(key);
        }


        /// 
        /// 获取多个Key
        /// 

        /// Redis Key集合
        /// 
        public static RedisValue[] GetStringKey(List listKey)
        {
            return db.StringGet(listKey.ToArray());
        }

        /// 
        /// 获取一个key的对象
        /// 

        /// 
        /// 
        /// 
        public static T GetStringKey(string key)
        {
            return JsonConvert.DeserializeObject(db.StringGet(key));
        }
        /// 
        /// 为数字增长val
        /// 

        /// 
        /// 可以为负
        /// 增长后的值
        public double StringIncrement(string key, double val = 1)
        {
            return db.StringIncrement(key, val);
        }

        /// 
        /// 为数字减少val
        /// 

        /// 
        /// 可以为负
        /// 减少后的值
        public double StringDecrement(string key, double val = 1)
        {
            return db.StringDecrement(key, val);
        }

        #endregion

        #region String 可以设置过期时间 异步

        /// 
        /// 保存单个key value
        /// 

        /// Redis Key
        /// 保存的值
        /// 过期时间
        /// 
        public static async Task SetStringKeyAsync(string key, string value, TimeSpan? expiry = default(TimeSpan?))
        {

            return await db.StringSetAsync(key, value, expiry);
        }

        /// 
        /// 保存多个key value
        /// 

        /// key
        /// 
        public static async Task SetStringKeyAsync(KeyValuePair[] arr)
        {
            return await db.StringSetAsync(arr);
        }

        /// 
        /// 保存一个对象
        /// 

        /// 
        /// 
        /// 
        /// 
        public static async Task SetStringKeyAsync(string key, T obj, TimeSpan? expiry = default(TimeSpan?))
        {
            string json = JsonConvert.SerializeObject(obj);
            return await db.StringSetAsync(key, json, expiry);
        }

        /// 
        /// 获取单个key的值
        /// 

        /// Redis Key
        /// 

        public static async Task  GetStringKeyAsync(string key)
        {
            return await db.StringGetAsync(key);
        }


        /// 
        /// 获取多个Key
        /// 

        /// Redis Key集合
        /// 
        public static async Task GetStringKeyAsync(List listKey)
        {
            return await db.StringGetAsync(listKey.ToArray());
        }

        /// 
        /// 获取一个key的对象
        /// 

        /// 
        /// 
        /// 
        public static async Task GetStringKeyAsync(string key)
        {
            return JsonConvert.DeserializeObject(await db.StringGetAsync(key));
        }
        /// 
        /// 为数字增长val
        /// 

        /// 
        /// 可以为负
        /// 增长后的值
        public async Task StringIncrementAsync(string key, double val = 1)
        {
            return await db.StringIncrementAsync(key, val);
        }

        /// 
        /// 为数字减少val
        /// 

        /// 
        /// 可以为负
        /// 减少后的值
        public async Task StringDecrementAsync(string key, double val = 1)
        {
            return await db.StringDecrementAsync(key, val);
        }
        #endregion

        #region Hash 同步
        /// 
        /// 存储数据到hash表
        /// 

        /// 
        /// 
        /// 
        /// 
        /// 
        public static bool HashSet1(string key, string dataKey, List t)
        {
            string json = "";
            foreach (var item in t)
            {
                json = JsonConvert.SerializeObject(item);
                //listHashEntry.Add(new HashEntry(getModelId(item), json));
            }
            return db.HashSet(key, dataKey, json);

            //return await  ({
            //    string json = ConvertJson(t);
            //    return db.HashSetAsync(key, dataKey, json);
            //});
        }
        /// 
        /// 保存一个集合
        /// 

        /// 
        /// Redis Key
        /// 数据集合
        /// 
        public static void HashSet(string key, List list, Func getModelId)
        {
            List listHashEntry = new List();
            foreach (var item in list)
            {
                string json = JsonConvert.SerializeObject(item);
                listHashEntry.Add(new HashEntry(getModelId(item), json));
            }
            db.HashSet(key, listHashEntry.ToArray());
        }

        /// 
        /// 获取Hash中的单个key的值
        /// 

        /// 
        /// Redis Key
        /// RedisValue
        /// 
        public static T GetHashKey(string key, string hasFildValue)
        {
            if (!string.IsNullOrWhiteSpace(key) && !string.IsNullOrWhiteSpace(hasFildValue))
            {
                RedisValue value = db.HashGet(key, hasFildValue);
                if (!value.IsNullOrEmpty)
                {
                    return JsonConvert.DeserializeObject(value);
                }
            }
            return default(T);
        }

        /// 
        /// 获取hash中的多个key的值
        /// 

        /// 
        /// Redis Key
        /// RedisValue value
        /// 
        public static List GetHashKey(string key, List listhashFields)
        {
            List result = new List();
            if (!string.IsNullOrWhiteSpace(key) && listhashFields.Count > 0)
            {
                RedisValue[] value = db.HashGet(key, listhashFields.ToArray());
                foreach (var item in value)
                {
                    if (!item.IsNullOrEmpty)
                    {
                        result.Add(JsonConvert.DeserializeObject(item));
                    }
                }
            }
            return result;
        }

        /// 
        /// 获取hashkey所有Redis key
        /// 

        /// 
        /// 
        /// 
        public static List GetHashAll(string key)
        {
            List result = new List();
            RedisValue[] arr = db.HashKeys(key);
            foreach (var item in arr)
            {
                if (!item.IsNullOrEmpty)
                {
                    result.Add(JsonConvert.DeserializeObject(item));
                }
            }
            return result;
        }

        /// 
        /// 获取hashkey所有的值
        /// 

        /// 
        /// 
        /// 
        public static List HashGetAll(string key)
        {
            List result = new List();
            HashEntry[] arr = db.HashGetAll(key);
            foreach (var item in arr)
            {
                if (!item.Value.IsNullOrEmpty)
                {
                    result.Add(JsonConvert.DeserializeObject(item.Value));
                }
            }
            return result;
        }

        /// 
        /// 删除hasekey
        /// 

        /// 
        /// 
        /// 
        public static bool DeleteHase(RedisKey key, RedisValue hashField)
        {
            return db.HashDelete(key, hashField);
        }

        #endregion

        #region Hash 异步
        /// 
        /// 存储数据到hash表
        /// 

        /// 
        /// 
        /// 
        /// 
        /// 
        public static async Task HashSetAsync(string key, string dataKey, List t)
        {
            string json = "";
            foreach (var item in t)
            {
                json = JsonConvert.SerializeObject(item);
                //listHashEntry.Add(new HashEntry(getModelId(item), json));
            }
            return await db.HashSetAsync(key, dataKey, json);

            //return await  ({
            //    string json = ConvertJson(t);
            //    return db.HashSetAsync(key, dataKey, json);
            //});
        }

        ///// 
        ///// 保存一个集合
        ///// 

        ///// 
        ///// Redis Key
        ///// 数据集合
        ///// 
        //public static async Task HashSetAsync(string key, List list, Func getModelId)
        //{
        //    List listHashEntry = new List();
        //    string json = "";
        //    foreach (var item in list)
        //    {
        //        json = JsonConvert.SerializeObject(item);
        //        listHashEntry.Add(new HashEntry(getModelId(item), json));
        //    }
        //   return await db.HashSetAsync(key, listHashEntry.ToArray());
        //}

        /// 
        /// 获取Hash中的单个key的值
        /// 

        /// 
        /// Redis Key
        /// RedisValue
        /// 
        public static async Task GetHashKeyAsync(string key, string hasFildValue)
        {
            if (!string.IsNullOrWhiteSpace(key) && !string.IsNullOrWhiteSpace(hasFildValue))
            {
                RedisValue value = await db.HashGetAsync(key, hasFildValue);
                if (!value.IsNullOrEmpty)
                {
                    return JsonConvert.DeserializeObject(value);
                }
            }
            return default(T);
        }

        /// 
        /// 获取hash中的多个key的值
        /// 

        /// 
        /// Redis Key
        /// RedisValue value
        /// 
        public static async Task<List> GetHashKeyAsync(string key, List listhashFields)
        {
            List result = new List();
            if (!string.IsNullOrWhiteSpace(key) && listhashFields.Count > 0)
            {
                RedisValue[] value = await db.HashGetAsync(key, listhashFields.ToArray());
                foreach (var item in value)
                {
                    if (!item.IsNullOrEmpty)
                    {
                        result.Add(JsonConvert.DeserializeObject(item));
                    }
                }
            }
            return result;
        }

        /// 
        /// 获取hashkey所有Redis key
        /// 

        /// 
        /// 
        /// 
        public static async Task<List> GetHashAllAsync(string key)
        {
            List result = new List();
            RedisValue[] arr =await db.HashKeysAsync(key);
            foreach (var item in arr)
            {
                if (!item.IsNullOrEmpty)
                {
                    result.Add(JsonConvert.DeserializeObject(item));
                }
            }
            return result;
        }

        /// 
        /// 获取hashkey所有的值
        /// 

        /// 
        /// 
        /// 
        public static async Task<List> HashGetAllAsync(string key)
        {
            List result = new List();
            HashEntry[] arr =await db.HashGetAllAsync(key);
            foreach (var item in arr)
            {
                if (!item.Value.IsNullOrEmpty)
                {
                    result.Add(JsonConvert.DeserializeObject(item.Value));
                }
            }
            return result;
        }

        /// 
        /// 删除hasekey
        /// 

        /// 
        /// 
        /// 
        public static async Task DeleteHaseAsync(RedisKey key, RedisValue hashField)
        {
            return await db.HashDeleteAsync(key, hashField);
        }

        #endregion

        #region key 同步

        /// 
        /// 删除单个key
        /// 

        /// redis key
        /// 是否删除成功
        public static bool KeyDelete(string key)
        {
            return db.KeyDelete(key);
        }

        /// 
        /// 删除多个key
        /// 

        /// rediskey
        /// 成功删除的个数
        public static long keyDelete(RedisKey[] keys)
        {
            return db.KeyDelete(keys);
        }

        /// 
        /// 判断key是否存储
        /// 

        /// redis key
        /// 
        public static bool KeyExists(string key)
        {
            return db.KeyExists(key);
        }

        /// 
        /// 重新命名key
        /// 

        /// 就的redis key
        /// 新的redis key
        /// 
        public static bool KeyRename(string key, string newKey)
        {
            return db.KeyRename(key, newKey);
        }

        /// 
        /// 设置Key的时间
        /// 

        /// redis key
        /// 
        /// 
        public static bool KeyExpire(string key, TimeSpan? expiry = default(TimeSpan?))
        {
            return db.KeyExpire(key, expiry);
        }
        #endregion

        #region key 异步

        /// 
        /// 删除单个key
        /// 

        /// redis key
        /// 是否删除成功
        public static async Task KeyDeleteAsync(string key)
        {
            return await db.KeyDeleteAsync(key);
        }

        /// 
        /// 删除多个key
        /// 

        /// rediskey
        /// 成功删除的个数
        public static async Task keyDeleteAsync(RedisKey[] keys)
        {
            return await db.KeyDeleteAsync(keys);
        }

        /// 
        /// 判断key是否存储
        /// 

        /// redis key
        /// 
        public static async Task KeyExistsAsync(string key)
        {
            return await db.KeyExistsAsync(key);
        }

        /// 
        /// 重新命名key
        /// 

        /// 就的redis key
        /// 新的redis key
        /// 
        public static async Task KeyRenameAsync(string key, string newKey)
        {
            return await db.KeyRenameAsync(key, newKey);
        }


        /// 
        /// 设置Key的时间
        /// 

        /// redis key
        /// 
        /// 
        public static async Task KeyExpireAsync(string key, TimeSpan? expiry = default(TimeSpan?))
        {
            return await db.KeyExpireAsync(key, expiry);
        }
        #endregion


        #region List 同步

        /// 
        /// 移除指定ListId的内部List的值
        /// 

        /// 
        /// 
        public void ListRemove(string key, T value)
        {
             db.ListRemove(key, JsonConvert.SerializeObject(value));
        }

        /// 
        /// 获取指定key的List
        /// 

        /// 
        /// 
        public List ListRange(string key)
        {
            var values = db.ListRange(key);
            List result = new List();
            foreach (var item in values)
            {
                var model = JsonConvert.DeserializeObject(item);
                result.Add(model);
            }
            return result;
        }

        /// 
        /// 入队
        /// 

        /// 
        /// 
        public void ListRightPush(string key, T value)
        {
            db.ListRightPush(key, JsonConvert.SerializeObject(value));
        }

        /// 
        /// 出队
        /// 

        /// 
        /// 
        /// 
        public T ListRightPop(string key)
        {
            var value = db.ListRightPop(key);
            return JsonConvert.DeserializeObject(value);
        }

        /// 
        /// 获取集合中的数量
        /// 

        /// 
        /// 
        public long ListLength(string key)
        {
            return db.ListLength(key);
        }

        #endregion 同步方法

        #region List 异步

        /// 
        /// 移除指定ListId的内部List的值
        /// 

        /// 
        /// 
        public async Task ListRemoveAsync(string key, T value)
        {
            return await db.ListRemoveAsync(key, JsonConvert.SerializeObject(value));
        }

        /// 
        /// 获取指定key的List
        /// 

        /// 
        /// 
        public async Task<List> ListRangeAsync(string key)
        {
            var values =await db.ListRangeAsync(key);
            List result = new List();
            foreach (var item in values)
            {
                var model = JsonConvert.DeserializeObject(item);
                result.Add(model);
            }
            return result;
        }

        /// 
        /// 入队
        /// 

        /// 
        /// 
        public async Task ListRightPushAsync(string key, T value)
        {
            return await db.ListRightPushAsync(key, JsonConvert.SerializeObject(value));
        }

        /// 
        /// 出队
        /// 

        /// 
        /// 
        /// 
        public async Task ListRightPopAsync(string key)
        {
            var value = await db.ListRightPopAsync(key);
            return JsonConvert.DeserializeObject(value);
        }

       
        /// 
        /// 获取集合中的数量
        /// 

        /// 
        /// 
        public async Task ListLengthAsync(string key)
        {
            return await db.ListLengthAsync(key);
        }

        #endregion 异步方法
        

        #region SortedSet 同步

        /// 
        /// 添加
        /// 

        /// 
        /// 
        /// 
        public static bool SortedSetAdd(string key, T value, double score)
        {
            return db.SortedSetAdd(key, JsonConvert.SerializeObject(value), score);
        }

        /// 
        /// 删除
        /// 

        /// 
        /// 
        public static bool SortedSetRemove(string key, T value)
        {
            return db.SortedSetRemove(key, JsonConvert.SerializeObject(value));
        }

        /// 
        /// 获取全部
        /// 

        /// 
        /// 
        public static List SortedSetRangeByRank(string key)
        {
                var values = db.SortedSetRangeByRank(key);

            List result = new List();
            foreach (var item in values)
            {
                var model = JsonConvert.DeserializeObject(item);
                result.Add(model);
            }
            return result;
        }

        /// 
        /// 获取集合中的数量
        /// 

        /// 
        /// 
        public static long SortedSetLength(string key)
        {
            return db.SortedSetLength(key);
        }

        #endregion 同步方法

        #region SortedSet 异步

        /// 
        /// 添加
        /// 

        /// 
        /// 
        /// 
        public static async Task SortedSetAddAsync(string key, T value, double score)
        {
            return await db.SortedSetAddAsync(key, JsonConvert.SerializeObject(value), score);
        }

        /// 
        /// 删除
        /// 

        /// 
        /// 
        public static async Task SortedSetRemoveAsync(string key, T value)
        {
            return await db.SortedSetRemoveAsync(key, JsonConvert.SerializeObject(value));
        }

        /// 
        /// 获取全部
        /// 

        /// 
        /// 
        public static async Task<List> SortedSetRangeByRankAsync(string key)
        {
            var values = await db.SortedSetRangeByRankAsync(key);
            List result = new List();
            foreach (var item in values)
            {
                var model = JsonConvert.DeserializeObject(item);
                result.Add(model);
            }
            return result;
        }

        /// 
        /// 获取集合中的数量
        /// 

        /// 
        /// 
        public static async Task SortedSetLengthAsync(string key)
        {
            return await db.SortedSetLengthAsync(key);
        }

        #endregion 异步方法
        

        /// 
        /// 追加值
        /// 

        /// 
        /// 
        public static void StringAppend(string key, string value)
        {
            ////追加值,返回追加后长度
            long appendlong = db.StringAppend(key, value);
        }

本文由职坐标整理并发布,希望对同学们有所帮助。了解更多详情请关注职坐标编程语言C#.NET频道!

本文由 @小标 发布于职坐标。未经许可,禁止转载。
喜欢 | 2 不喜欢 | 0
看完这篇文章有何感觉?已经有2人表态,100%的人喜欢 快给朋友分享吧~
评论(0)
后参与评论

您输入的评论内容中包含违禁敏感词

我知道了

助您圆梦职场 匹配合适岗位
验证码手机号,获得海同独家IT培训资料
选择就业方向:
人工智能物联网
大数据开发/分析
人工智能Python
Java全栈开发
WEB前端+H5

请输入正确的手机号码

请输入正确的验证码

获取验证码

您今天的短信下发次数太多了,明天再试试吧!

提交

我们会在第一时间安排职业规划师联系您!

您也可以联系我们的职业规划师咨询:

小职老师的微信号:z_zhizuobiao
小职老师的微信号:z_zhizuobiao

版权所有 职坐标-一站式IT培训就业服务领导者 沪ICP备13042190号-4
上海海同信息科技有限公司 Copyright ©2015 www.zhizuobiao.com,All Rights Reserved.
 沪公网安备 31011502005948号    

©2015 www.zhizuobiao.com All Rights Reserved

208小时内训课程