Exemple #1
0
        /// <summary>
        /// 从hash表获取数据
        /// </summary>
        /// <param name="keys"></param>
        /// <returns></returns>
        public Dictionary <string, Dictionary <string, string> > HashGet(Dictionary <string, string[]> keys)
        {
            Dictionary <string, Dictionary <string, string> > dic =
                new Dictionary <string, Dictionary <string, string> >();

            if (keys != null && keys.Count > 0)
            {
                Dictionary <string, string[]> values = QuickHelperBase.HashGet(keys);

                foreach (var item in keys)
                {
                    string[] valuesList = values.Where(x => x.Key == string.Concat(QuickHelperBase.Name, item.Key))
                                          .Select(x => x.Value).FirstOrDefault();
                    Dictionary <string, string> newDic = new Dictionary <string, string>();
                    if (valuesList != null && valuesList.Length > 0)
                    {
                        for (int i = 0; i < item.Value.Length; i++)
                        {
                            if (!newDic.ContainsKey(item.Value[i]) && valuesList[i] != null)
                            {
                                newDic.Add(item.Value[i], valuesList[i]);
                            }
                        }
                    }

                    dic.Add(item.Key, newDic);
                }
            }

            return(dic);
        }
Exemple #2
0
        /// <summary>
        /// 获取指定key的List
        /// </summary>
        /// <param name="key"></param>
        /// <param name="count"></param>
        /// <returns></returns>
        public List <T> ListRange <T>(string key, long count = 1000) where T : class, new()
        {
            List <T> list = new List <T>();

            QuickHelperBase.LRang(key, 0, count).ToList().ForEach(p => { list.Add(ConvertObj <T>(p)); });
            return(list);
        }
Exemple #3
0
        /// <summary>
        /// 存储数据到hash表
        /// </summary>
        /// <param name="kValues"></param>
        /// <param name="second"></param>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public bool HashSet <T>(Dictionary <string, Dictionary <string, T> > kValues, long second = -1,
                                bool isSetHashKeyExpire = true)
        {
            Dictionary <string, object[]> keyValues = new Dictionary <string, object[]>();

            foreach (var item in kValues)
            {
                List <object> dataKeyValues = new List <object>();
                foreach (var kvp in item.Value)
                {
                    dataKeyValues.Add(isSetHashKeyExpire ? GetKey(kvp.Key) : kvp.Key);
                    dataKeyValues.Add(ConvertJson(kvp.Value));
                }

                keyValues.Add(isSetHashKeyExpire ? GetKey(item.Key) : item.Key, dataKeyValues.ToArray());
            }

            if (isSetHashKeyExpire)
            {
                return(string.Equals(QuickHelperBase.HashSetHashFileExpire(keyValues, GetExpire(second)), "OK",
                                     StringComparison.OrdinalIgnoreCase));
            }

            return(string.Equals(QuickHelperBase.HashSetExpire(keyValues, GetExpire(second)), "OK",
                                 StringComparison.OrdinalIgnoreCase));
        }
Exemple #4
0
        /// <summary>
        /// 查找所有符合给定模式( pattern)的 key
        /// </summary>
        /// <param name="pattern">如:runoob*,不含prefix前辍RedisHelper.Name</param>
        /// <returns></returns>
        public List <string> Keys(string pattern)
        {
            var keys = new List <string>();

            QuickHelperBase.Keys(_prefix + pattern).ToList().ForEach(p => { keys.Add(p.Substring(_prefix.Length)); });
            return(keys);
        }
Exemple #5
0
 /// <summary>
 /// 保存一个对象
 /// </summary>
 /// <typeparam name="T"></typeparam>
 /// <param name="key"></param>
 /// <param name="obj"></param>
 /// <param name="expiry"></param>
 /// <param name="overdueStrategy"></param>
 /// <returns></returns>
 public Task <bool> StringSetAsync <T>(string key, T obj, TimeSpan?expiry = default(TimeSpan?),
                                       OverdueStrategy overdueStrategy    = null)
 {
     return(base.Execute(overdueStrategy, () => QuickHelperBase.SetAsync(key, ConvertJson <T>(obj),
                                                                         expiry.HasValue ? Convert.ToInt32(expiry.Value.TotalSeconds) : -1),
                         () => { return Task.FromResult(false); }));
 }
Exemple #6
0
 /// <summary>
 /// 存储数据到hash表
 /// </summary>
 /// <typeparam name="T"></typeparam>
 /// <param name="key"></param>
 /// <param name="dataKey"></param>
 /// <param name="t"></param>
 /// <param name="overdueStrategy"></param>
 /// <returns></returns>
 public async Task <bool> HashSetAsync <T>(string key, string dataKey, T t, OverdueStrategy overdueStrategy = null)
 {
     return((await base.Execute(overdueStrategy,
                                () => { return QuickHelperBase.HashSetAsync(key, dataKey, ConvertJson <T>(t)); },
                                () => { return Task.FromResult("False"); })).Equals("TRUE", StringComparison.OrdinalIgnoreCase));
     // return string.Equals(await QuickHelperBase.HashSetAsync(key, dataKey, ConvertJson<T>(t)), "TRUE",
     //     StringComparison.OrdinalIgnoreCase);
 }
Exemple #7
0
        /// <summary>
        /// 添加 (当score一样value一样时不插入)
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <param name="score"></param>
        /// <param name="isOverlap"></param>
        /// <returns></returns>
        public bool SortedSetAdd <T>(string key, T value, double score, bool isOverlap = false)
        {
            if (isOverlap)
            {
                SortedSetRemove <T>(key, value);
            }

            return(QuickHelperBase.ZAdd(key, (score, ConvertJson <T>(value))) > 0);
        }
Exemple #8
0
        /// <summary>
        /// 获取已过期的hashKey
        /// 其中Item1为SortSet的Key,Item2为SortSet的Value,Item3为HashSet的Key,Item4为HashSet的HashKey
        /// </summary>
        /// <param name="count"></param>
        /// <returns></returns>
        public List <ValueTuple <string, string, string, string> > SortedSetRangeByRankAndOverTime(long count = 1000)
        {
            var keyList = QuickHelperBase
                          .ZRevRangeByScore(QuickHelperBase.GetCacheFileKeys(), TimeCommon.GetTimeSpan(DateTime.Now), 0, count,
                                            null); //得到过期的key集合
            List <ValueTuple <string, string, string, string> > result = new List <(string, string, string, string)>();

            keyList.ForEach(item =>
            {
                for (int i = 0; i < item.Item2.Length; i += 2)
                {
                    result.Add((item.Item1.Replace(_prefix, ""), item.Item2[i].ToString(),
                                item.Item2[i].ToString().Replace("~_~", "!").Split('!')[0],
                                item.Item2[i].ToString().Replace("~_~", "!").Split('!')[1]));
                }
            });
            return(result);
        }
Exemple #9
0
        /// <summary>
        /// 存储数据到hash表
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="dataKey"></param>
        /// <param name="t"></param>
        /// <param name="second">秒</param>
        /// <param name="isSetHashKeyExpire">false:设置key的过期时间,true:设置hashkey的过期时间,默认设置的为HashKey的过期时间。</param>
        /// <returns></returns>
        public bool HashSet <T>(string key, string dataKey, T t, long second = -1, bool isSetHashKeyExpire = true)
        {
            string value = "";

            if (!isSetHashKeyExpire)
            {
                value =
                    QuickHelperBase.HashSetExpire(key, GetExpire(second), dataKey, ConvertJson(t));
            }
            else
            {
                value = QuickHelperBase.HashSetHashFileExpire(GetKey(key), GetKey(dataKey), GetExpire(second),
                                                              ConvertJson(t));
            }

            bool result = string.Equals(value, "OK",
                                        StringComparison.OrdinalIgnoreCase);

            return(result);
        }
Exemple #10
0
        /// <summary>
        /// 从hash表获取数据
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="dataKeys"></param>
        /// <returns></returns>
        public Dictionary <string, string> HashGet(string key, List <string> dataKeys)
        {
            if (dataKeys != null && dataKeys.Count > 0)
            {
                dataKeys = dataKeys.Distinct().ToList();
                var values = QuickHelperBase.HashGet(key, dataKeys.ToArray()).ToList();

                Dictionary <string, string> dic = new Dictionary <string, string>();
                for (int i = 0; i < dataKeys.Count; i++)
                {
                    if (!dic.ContainsKey(dataKeys[i]) && values[i] != null)
                    {
                        dic.Add(dataKeys[i], values[i]);
                    }
                }

                return(dic);
            }

            return(QuickHelperBase.HashGetAll(key));
        }
Exemple #11
0
        /// <summary>
        ///  存储数据到hash表
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="kvalues"></param>
        /// <param name="second">秒</param>
        /// <param name="isSetHashKeyExpire"></param>
        /// <returns></returns>
        public bool HashSet <T>(string key, Dictionary <string, T> kvalues, long second = -1,
                                bool isSetHashKeyExpire = true)
        {
            List <object> keyValues = new List <object>();

            foreach (var kvp in kvalues)
            {
                keyValues.Add(isSetHashKeyExpire ? GetKey(kvp.Key) : kvp.Key);
                keyValues.Add(ConvertJson(kvp.Value));
            }

            if (isSetHashKeyExpire)
            {
                return(string.Equals(
                           QuickHelperBase.HashSetHashFileExpire(GetKey(key), GetExpire(second), keyValues.ToArray()),
                           "OK",
                           StringComparison.OrdinalIgnoreCase));
            }

            return(string.Equals(QuickHelperBase.HashSetExpire(key, GetExpire(second), keyValues.ToArray()), "OK",
                                 StringComparison.OrdinalIgnoreCase));
        }
Exemple #12
0
        /// <summary>
        /// 存储数据到hash表
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="dataKey"></param>
        /// <param name="t"></param>
        /// <param name="second">秒</param>
        /// <param name="isSetHashKeyExpire">false:设置key的过期时间(整个键使用一个过期时间),true:设置hashkey的过期时间,默认设置的为HashKey的过期时间(单个datakey使用一个过期时间)。</param>
        /// <param name="overdueStrategy"></param>
        /// <returns></returns>
        public bool HashSet <T>(string key, string dataKey, T t, long second = -1L, bool isSetHashKeyExpire = true,
                                OverdueStrategy overdueStrategy = null)
        {
            string value = "";

            return(base.Execute(overdueStrategy, () =>
            {
                if (!isSetHashKeyExpire)
                {
                    value =
                        QuickHelperBase.HashSetExpire(key, GetExpire(second), dataKey, ConvertJson(t));
                }
                else
                {
                    value = QuickHelperBase.HashSetHashFileExpire(GetKey(key), GetKey(dataKey), GetExpire(second),
                                                                  ConvertJson(t));
                }

                bool result = string.Equals(value, "OK",
                                            StringComparison.OrdinalIgnoreCase);
                return result;
            }, () => { return false; }));
        }
Exemple #13
0
 /// <summary>
 /// 获取单个key的值
 /// </summary>
 /// <param name="key">Redis Key</param>
 /// <returns></returns>
 public string StringGet(string key)
 {
     return(QuickHelperBase.Get(key));
 }
Exemple #14
0
 /// <summary>
 /// 获取全部
 /// </summary>
 /// <param name="key"></param>
 /// <param name="count"></param>
 /// <returns></returns>
 public List <T> SortedSetRangeByRank <T>(string key, long count = 1000) where T : class, new()
 {
     return(ConvertListObj <T>(QuickHelperBase.ZRange(key, 0, count).ToList()));
 }
Exemple #15
0
 /// <summary>
 /// 获取全部
 /// </summary>
 /// <param name="key"></param>
 /// <param name="count"></param>
 /// <returns></returns>
 public List <string> SortedSetRangeByRank(string key, long count = 1000)
 {
     return(QuickHelperBase.ZRange(key, 0, count).ToList());
 }
Exemple #16
0
 /// <summary>
 /// 删除
 /// </summary>
 /// <param name="key"></param>
 /// <param name="value"></param>
 /// <returns></returns>
 public bool SortedSetRemove <T>(string key, T value)
 {
     return(QuickHelperBase.ZRem(key, new string[1] {
         ConvertJson <T>(value)
     }) > 0);
 }
Exemple #17
0
 /// <summary>
 /// 获取集合中的数量
 /// </summary>
 /// <param name="key"></param>
 /// <returns></returns>
 public long ListLength(string key)
 {
     return(QuickHelperBase.LLen(key));
 }
Exemple #18
0
 /// <summary>
 /// 保存一个对象
 /// </summary>
 /// <typeparam name="T"></typeparam>
 /// <param name="key"></param>
 /// <param name="obj"></param>
 /// <param name="expiry"></param>
 /// <returns></returns>
 public bool StringSet <T>(string key, T obj, TimeSpan?expiry = default(TimeSpan?))
 {
     return(QuickHelperBase.Set(key, ConvertJson(obj),
                                expiry.HasValue ? Convert.ToInt32(expiry.Value.TotalSeconds) : -1));
 }
Exemple #19
0
 /// <summary>
 /// 入栈
 /// </summary>
 /// <typeparam name="T"></typeparam>
 /// <param name="key"></param>
 /// <param name="value"></param>
 /// <returns></returns>
 public async Task <long> ListLeftPushAsync <T>(string key, T value)
 {
     return(await QuickHelperBase.LPushAsync(key, new string[1] {
         ConvertJson <T>(value)
     }));
 }
Exemple #20
0
 /// <summary>
 /// 入队
 /// </summary>
 /// <param name="key"></param>
 /// <param name="value"></param>
 /// <returns></returns>
 public async Task <long> ListRightPushAsync <T>(string key, T value)
 {
     return(await QuickHelperBase.RPushAsync(key, new[] { ConvertJson(value) }));
 }
Exemple #21
0
 /// <summary>
 /// 获取指定key的List
 /// </summary>
 /// <param name="key"></param>
 /// <param name="count"></param>
 /// <returns></returns>
 public async Task <List <T> > ListRangeAsync <T>(string key, long count = 1000) where T : class, new()
 {
     return(ConvertListObj <T>((await QuickHelperBase.LRangAsync(key, 0, count)).ToList()));
 }
Exemple #22
0
 /// <summary>
 /// 获取指定key的List
 /// </summary>
 /// <param name="key"></param>
 /// <param name="count"></param>
 /// <returns></returns>
 public async Task <List <string> > ListRangeAsync(string key, long count = 1000)
 {
     return((await QuickHelperBase.LRangAsync(key, 0, count)).ToList());
 }
Exemple #23
0
 /// <summary>
 /// 移除指定ListId的内部List的值
 /// </summary>
 /// <param name="key"></param>
 /// <param name="value"></param>
 /// <returns></returns>
 public async Task <long> ListRemoveAsync <T>(string key, T value)
 {
     return(await QuickHelperBase.LRemAsync(key, int.MaxValue, ConvertJson(value)));
 }
Exemple #24
0
 /// <summary>
 /// 降序获取指定索引的集合
 /// </summary>
 /// <typeparam name="T"></typeparam>
 /// <param name="key"></param>
 /// <param name="fromRank"></param>
 /// <param name="toRank"></param>
 /// <returns></returns>
 public List <string> GetRangeFromSortedSetDesc(string key, long fromRank, long toRank)
 {
     return(QuickHelperBase.ZRevRange(key, fromRank, toRank).ToList());
 }
Exemple #25
0
 /// <summary>
 /// 降序获取指定索引的集合
 /// </summary>
 /// <typeparam name="T"></typeparam>
 /// <param name="key"></param>
 /// <param name="fromRank"></param>
 /// <param name="toRank"></param>
 /// <returns></returns>
 public List <T> GetRangeFromSortedSetDesc <T>(string key, long fromRank, long toRank) where T : class, new()
 {
     return(ConvertListObj <T>(QuickHelperBase.ZRevRange(key, fromRank, toRank).ToList()));
 }
Exemple #26
0
 /// <summary>
 /// 出栈
 /// </summary>
 /// <typeparam name="T"></typeparam>
 /// <param name="key"></param>
 /// <returns></returns>
 public async Task <T> ListLeftPopAsync <T>(string key) where T : class, new()
 {
     return(ConvertObj <T>(await QuickHelperBase.LPopAsync(key)));
 }
Exemple #27
0
 /// <summary>
 /// 获取集合中的数量
 /// </summary>
 /// <param name="key"></param>
 /// <returns></returns>
 public async Task <long> ListLengthAsync(string key)
 {
     return(await QuickHelperBase.LLenAsync(key));
 }
Exemple #28
0
 /// <summary>
 /// 保存单个key value
 /// </summary>
 /// <param name="key">Redis Key</param>
 /// <param name="value">保存的值</param>
 /// <param name="expiry">过期时间</param>
 /// <returns></returns>
 public bool StringSet(string key, string value, TimeSpan?expiry = default(TimeSpan?))
 {
     return(QuickHelperBase.Set(key, value, expiry.HasValue ? Convert.ToInt32(expiry.Value.TotalSeconds) : -1));
 }
Exemple #29
0
 /// <summary>
 /// 出栈
 /// </summary>
 /// <typeparam name="T"></typeparam>
 /// <param name="key"></param>
 /// <returns></returns>
 public async Task <string> ListLeftPopAsync(string key)
 {
     return(await QuickHelperBase.LPopAsync(key));
 }
Exemple #30
0
 /// <summary>
 /// 出栈
 /// </summary>
 /// <typeparam name="T"></typeparam>
 /// <param name="key"></param>
 /// <returns></returns>
 public T ListLeftPop <T>(string key) where T : class, new()
 {
     return(ConvertObj <T>(QuickHelperBase.LPop(key)));
 }