Redis之 散列（hashes）

Redis hash 看起来就像一个 “hash” 的样子，由键值对组成：

Hash 便于表示 objects，实际上，你可以放入一个 hash 的域数量实际上没有限制（除了可用内存以外）。所以，你可以在你的应用中以不同的方式使用 hash。

值得注意的是，小的 hash 被用特殊方式编码，非常节约内存。

1、删除操作

        /// <summary>
        /// 根据hashId移除指定key的数据
        /// 原指令：HDEL key field [field ...]
        /// 时间复杂度：O(1)
        /// 参考：http://www.redis.cn/commands/hdel.html
        /// </summary>
        public bool Remove(string hashId, string key)
        {
            return Redis.RemoveEntryFromHash(hashId, key);
        }

        /// <summary>
        /// 移除未指定hashId的key数据
        /// 从 key 指定的哈希集中移除指定的域。在哈希集中不存在的域将被忽略。
        /// 如果 key 指定的哈希集不存在，它将被认为是一个空的哈希集，该命令将返回0。
        /// 原指令：HDEL key field [field ...]
        /// 时间复杂度：O(N) N是被删除的字段数量。
        /// </summary>
        public bool Remove(string key)
        {
            return Redis.Remove(key);
        }

        /// <summary>
        /// 移除未指定hashId的所有keys的数据
        /// 原指令：HDEL key field [field ...]
        /// 时间复杂度：O(N) N是被删除的字段数量。
        /// </summary>
        /// <param name="keys"></param>
        /// <returns></returns>
        public void RemoveAll(string[] keys)
        {
            Redis.RemoveAll(keys);
        }
       

2、Set操作

/// <summary>
        /// 设置 key 指定的哈希集中指定字段的值。
        /// 如果 key 指定的哈希集不存在，会创建一个新的哈希集并与 key 关联。
        /// 如果字段在哈希集中存在，它将被重写,返回False。
        /// 原指令：HSET key field value
        /// 时间复杂度：O(1)
        /// 
        /// </summary>
        public bool Set<T>(string hashId, string key, T t)
        {
            string value = redisOper.SerializeToString<T>(t);
            return Redis.SetEntryInHash(hashId, key, value);
        }

        /// <summary>
        /// 设置 key 指定的哈希集中指定字段的值。
        /// 如果不存在则写入,true，如果存在则不写入返回false
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="hashId"></param>
        /// <param name="key"></param>
        /// <param name="t"></param>
        /// <returns></returns>
        public bool SetIfNotExists<T>(string hashId, string key, T t)
        {
            string value = redisOper.SerializeToString<T>(t);
            return Redis.SetEntryInHashIfNotExists(hashId, key, value);
        }

3、Get 操作

/// <summary>
        /// 返回 key 指定的哈希集包含的字段的数量。
        /// 原指令：HLEN key
        /// 时间复杂度：O(1)
        /// 参考：http://www.redis.cn/commands/hlen.html
        /// </summary>
        /// <param name="hashId"></param>
        /// <returns></returns>
        public long GetLen(string hashId)
        {
            return Redis.GetHashCount(hashId);
        }

        /// <summary>
        /// 返回 key 指定的哈希集中该字段所关联的值
        /// 原指令：HGET key field
        /// 时间复杂度：O(1)
        /// 参考：http://www.redis.cn/commands/hget.html
        /// </summary>
        public T Get<T>(string hashId, string key)
        {
            string value = Redis.GetValueFromHash(hashId, key);
            return redisOper.DeserializeFromString<T>(value);
        }

        /// <summary>
        /// 返回 key 指定的哈希集中指定字段的值。
        /// 对于哈希集中不存在的每个字段，返回 nil 值。因为不存在的keys被认为是一个空的哈希集，
        /// 对一个不存在的 key 执行 HMGET 将返回一个只含有 nil 值的列表
        /// 原指令：HMGET key field [field ...]
        /// 时间复杂度：O(N)
        /// 参考：http://www.redis.cn/commands/hmget.html
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="hashId"></param>
        /// <param name="keys"></param>
        /// <returns></returns>
        public List<T> GetMValues<T>(string hashId, string[] keys)
        {
            var result = new List<T>();
            var list = Redis.GetValuesFromHash(hashId, keys);
            if (list != null && list.Count > 0)
            {
                list.ForEach(x =>
                {
                    result.Add(redisOper.DeserializeFromString<T>(x));
                });
            }
            return result;
        }

        /// <summary>
        /// 返回 hashId 指定的哈希集中所有字段的key。
        /// 原指令：HGETALL key 返回 key 指定的哈希集中所有的字段和值。返回值中，每个字段名的下一个是它的值，所以返回值的长度是哈希集大小的两倍
        /// 时间复杂度：O(N)
        /// 参考：http://www.redis.cn/commands/hgetall.html
        /// </summary>
        /// <param name="hashId"></param>
        /// <returns></returns>
        public List<string> GetAllKeys(string hashId)
        {
            return Redis.GetHashKeys(hashId);
        }

        /// <summary>
        /// 返回 hashId 指定的哈希集中所有字段的值。
        /// 原指令：HVALS key/HGETALL key 这2个命令都可以 未看源码具体实现未知
        /// 时间复杂度：O(N)
        /// 参考：http://www.redis.cn/commands/hvals.html
        /// </summary>
        public List<T> GetAllValues<T>(string hashId)
        {
            var result = new List<T>();
            var list = Redis.GetHashValues(hashId);
            if (list != null && list.Count > 0)
            {
                list.ForEach(x =>
                {
                    result.Add(redisOper.DeserializeFromString<T>(x));
                });
            }
            return result;
        }

        /// <summary>
        /// 获取所有hashid数据集的key/value数据集合
        /// </summary>
        public Dictionary<string, T> GetAllEntriesFromHash<T>(string hashId)
        {
            var result = new Dictionary<string, T>();
            var list = Redis.GetAllEntriesFromHash(hashId);
            if (list != null && list.Count > 0)
            {
                foreach (var kv in list)
                {
                    result.Add(kv.Key, redisOper.DeserializeFromString<T>(kv.Value));
                }
            }
            return result;
        }

4、其他

/// <summary>
        /// 判断某个数据是否存在
        /// 原指令：HEXISTS key field
        /// 时间复杂度：O(1)
        /// 参考：http://www.redis.cn/commands/hexists.html
        /// </summary>
        public bool Exist(string hashId, string key)
        {
            return Redis.HashContainsEntry(hashId, key);
        }


        /// <summary>
        /// i++,i--操作 自增自减操作
        /// 给hashid数据集key的value加countby，返回相加后的数据
        /// 为指定key的hash的field字段值执行float类型的increment加。如果field不存在，则在执行该操作前设置为0.如果出现下列情况之一，则返回错误： 
        /// field的值包含的类型错误(不是字符串)。当前field或者increment不能解析为一个float类型。
        /// 原指令：HINCRBYFLOAT key field increment
        /// 时间复杂度：O(1)
        /// 参考：http://www.redis.cn/commands/hincrbyfloat.html
        /// </summary>
        public long IncrementValueInHash(string hashId, string key, int countBy)
        {
            return Redis.IncrementValueInHash(hashId, key, countBy);
        }

        /// <summary>
        /// i++,i--操作 自增自减操作
        /// 给hashid数据集key的value加countby，返回相加后的数据
        /// 为指定key的hash的field字段值执行float类型的increment加。如果field不存在，则在执行该操作前设置为0.如果出现下列情况之一，则返回错误： 
        /// field的值包含的类型错误(不是字符串)。当前field或者increment不能解析为一个float类型。
        /// 原指令：HINCRBYFLOAT key field increment
        /// 时间复杂度：O(1)
        /// 参考：http://www.redis.cn/commands/hincrbyfloat.html
        /// </summary>
        public double IncrementValueInHash(string hashId, string key, double countBy)
        {
            return Redis.IncrementValueInHash(hashId, key, countBy);
        }

        /// <summary>
        /// i++,i--操作 自增自减操作
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public long IncrementValueBy(string key)
        {
            return Redis.IncrementValue(key);
        }

        /// <summary>
        /// i++,i--操作 自增自减操作
        /// 增加 key 指定的哈希集中指定字段的数值。如果 key 不存在，会创建一个新的哈希集并与 key 关联。
        /// 如果字段不存在，则字段的值在该操作执行前被设置为 0HINCRBY 支持的值的范围限定在 64位 有符号整数
        /// 原指令：HINCRBY key field increment
        /// 时间复杂度：O(1)
        /// 参考：http://www.redis.cn/commands/hincrby.html
        /// </summary>
        public long IncrementValueBy(string key, int countBy)
        {
            return Redis.IncrementValueBy(key, countBy);
        }

        public long IncrementValueBy(string key, long countBy)
        {
            return Redis.IncrementValueBy(key, countBy);
        }

        public double IncrementValueBy(string key, double countBy)
        {
            return Redis.IncrementValueBy(key, countBy);
        }

        /// <summary>
        /// 设置缓存过期
        /// 未指定hashId 可以设置过期时间
        /// </summary>
        /// <param name="key"></param>
        /// <param name="datetime"></param>
        /// <returns></returns>
        public bool SetExpire(string key, DateTime datetime)
        {
            return Redis.ExpireEntryAt(key, datetime);
        }

        /// <summary>
        /// 设置缓存过期
        /// 未指定hashId 可以设置过期时间
        /// </summary>
        /// <param name="key"></param>
        /// <param name="expireIn"></param>
        /// <returns></returns>
        public bool ExpireEntryIn(string key, TimeSpan expireIn)
        {
            return Redis.ExpireEntryIn(key, expireIn);
        }