Redis之列表（Lists）

￡神魔★判官ぃ 2022-06-06 13:16 319阅读 0赞

插入列表，可以使用lpush和rpush命令，left可以视为表头，right可以视为表尾。

可以实现先进先出队列（FIFO）以及栈（LIFO）

队列在web应用的范围非常广，比如日志推送、任务处理等等；使用redis的list类型，也可以实现队列。

1、入栈

/// <summary>
            /// 从左侧(队首)向list中添加值
            /// 将所有指定的值插入到存于 key 的列表的头部。如果 key 不存在，那么在进行 push 操作前会创建一个空列表。 
            /// 如果 key 对应的值不是一个 list 的话，那么会返回一个错误。
            /// 可以使用一个命令把多个元素 push 进入列表，只需在命令末尾加上多个指定的参数。元素是从最左端的到最右端的、一个接一个被插入到 list 的头部。 
            /// 所以对于这个命令例子 LPUSH mylist a b c，返回的列表是 c 为第一个元素， b 为第二个元素， a 为第三个元素。
            /// 原指令：LPUSH key value [value ...]
            /// 时间复杂度：O(1)
            /// 参考：http://www.redis.cn/commands/lpush.html
            /// </summary>
            public void LPush(string key, string value)
            {
                //将一个值插入到List<T>的最前面
                Redis.PrependItemToList(key, value);
            }
            /// <summary>
            /// 从左侧向list中添加值，并设置过期时间（过期时间为List的过期时间）
            /// </summary>
            public void LPush(string key, string value, DateTime dt)
            {
                Redis.PrependItemToList(key, value);
                Redis.ExpireEntryAt(key, dt);
            }
            /// <summary>
            /// 从左侧(队首)向list中添加值，设置过期时间（过期时间为List的过期时间）
            /// </summary>
            public void LPush(string key, string value, TimeSpan sp)
            {
                Redis.PrependItemToList(key, value);
                Redis.ExpireEntryIn(key, sp);
            }
    
            /// <summary>
            /// 一次性添加多个值到指定ListId的内置List<T>中
            /// </summary>
            /// <param name="key"></param>
            /// <param name="values"></param>
            public void LPushRange(string key, List<string> values)
            {
                Redis.PrependRangeToList(key, values);
            }
    
            /// <summary>
            /// 向存于 key 的列表的右侧(尾部)插入所有指定的值。如果 key 不存在，那么会创建一个空的列表然后再进行 push 操作。 
            /// 当 key 保存的不是一个列表，那么会返回一个错误。
            /// 可以使用一个命令把多个元素打入队列，只需要在命令后面指定多个参数。元素是从左到右一个接一个从列表尾部插入。 
            /// 比如命令 RPUSH mylist a b c 会返回一个列表，其第一个元素是 a ，第二个元素是 b ，第三个元素是 c。
            /// 原指令：RPUSH key value [value ...]
            /// 时间复杂度：O(1)
            /// 参考：http://www.redis.cn/commands/rpush.html
            /// </summary>
            public void RPush(string key, string value)
            {
                //在指定ListId的内置List<T>中入列一个键值对，在末尾
                Redis.PushItemToList(key, value);
            }
    
            /// <summary>
            /// 从右侧(队尾)向list中添加值，并设置过期时间
            /// </summary>    
            public void RPush(string key, string value, DateTime dt)
            {
                Redis.PushItemToList(key, value);
                Redis.ExpireEntryAt(key, dt);
            }
            /// <summary>
            /// 从右侧(队尾)向list中添加值，并设置过期时间
            /// </summary>        
            public void RPush(string key, string value, TimeSpan sp)
            {
                Redis.PushItemToList(key, value);
                Redis.ExpireEntryIn(key, sp);
            }

2、出栈

/// <summary>
            /// 从指定ListId的List<T>右侧(队尾)移除一项并返回(从栈中获取最后进栈的数据，先进后出原则)
            /// 移除并返回存于 key 的 list 的最后一个元素。
            /// 最后一个元素的值，或者当 key 不存在的时候返回 nil。
            /// 原指令：RPOP key
            /// 时间复杂度：O(1)
            /// 参考：http://www.redis.cn/commands/rpop.html
            /// </summary>
            /// <param name="key"></param>
            public string Pop(string key)
            {
                return Redis.PopItemFromList(key);
            }
    /// <summary>
            /// 从一个list的右侧(队尾)移除一个数据，添加到另外一个list的头部，并返回移动的值
            /// 原子性地返回并移除存储在 source 的列表的最后一个元素（列表尾部元素）， 并把该元素放入存储在 destination 的列表的第一个元素位置（列表头部）。
            /// 假设 source 存储着列表 a,b,c， destination存储着列表 x,y,z。 执行 RPOPLPUSH 得到的结果是 source 保存着列表 a,b ，而 destination 保存着列表 c,x,y,z。
            /// 如果 source 不存在，那么会返回 nil 值，并且不会执行任何操作。 如果 source 和 destination 是同样的，那么这个操作等同于移除列表最后一个元素并且把该元素放在列表头部， 所以这个命令也可以当作是一个旋转列表的命令。
            /// 原指令RPOPLPUSH source destination
            /// 时间复杂度：O(1)
            /// 参考:http://www.redis.cn/commands/rpoplpush.html
            /// 模式：安全的队列、循环列表
            /// </summary>
            /// <param name="fromKey"></param>
            /// <param name="toKey"></param>
            public string PopAndPustItem(string fromKey, string toKey)
            {
                return Redis.PopAndPushItemBetweenLists(fromKey, toKey);
            }
    /// <summary>
            /// 阻塞地将指定ListId的List<T>末尾的那一个元素移除，并返回移除的值
            /// </summary>
            /// <param name="key"></param>
            /// <param name="sp"></param>
            /// <returns></returns>
            public string BlockingPopItemFromList(string key, TimeSpan? sp)
            {
                return Redis.BlockingPopItemFromList(key, sp);
            }
    
            /// <summary>
            ///  阻塞地将指定ListId[]的List<T>末尾的那一个元素移除，并返回移除的值
            /// </summary>  
            public ItemRef BlockingPopItemFromLists(string[] keys, TimeSpan? sp)
            {
                return Redis.BlockingPopItemFromLists(keys, sp);
            }
    
            /// <summary>
            /// 阻塞地从指定ListId移除开头那一项，并返回移除的值
            /// </summary>  
            public string BlockingRemoveStartFromList(string keys, TimeSpan? sp)
            {
                return Redis.BlockingRemoveStartFromList(keys, sp);
            }
            /// <summary>
            /// 阻塞命令：从list中key的头部移除一个值，并返回移除的值，阻塞时间为sp
            /// </summary>  
            public ItemRef BlockingRemoveStartFromLists(string[] keys, TimeSpan? sp)
            {
                return Redis.BlockingRemoveStartFromLists(keys, sp);
            }
            /// <summary>
            /// 将第一个集合的元素移除并添加到第二个集合的头部，返回该元素，会同时阻塞两个集合
            /// </summary>  
            public string BlockingPopAndPushItemBetweenLists(string fromkey, string tokey, TimeSpan? sp)
            {
                return Redis.BlockingPopAndPushItemBetweenLists(fromkey, tokey, sp);
            }

3、队列操作

/// <summary>
            /// 往队列中写入(队首)数据
            /// 将一个元素存入指定ListId的List<T>的头部
            /// </summary>
            /// <param name="key"></param>
            /// <param name="value"></param>
            public void EnqueueItemOnList(string key, string value)
            {
                Redis.EnqueueItemOnList(key, value);
            }
    
            /// <summary>
            /// 从队列中获取(队尾)最先进队列的数据，先进先出原则
            /// 将指定ListId的List<T>末尾的那个元素出列，返回出列元素
            /// </summary>
            /// <param name="key"></param>
            /// <returns></returns>
            public string DequeueItemFromList(string key)
            {
                return Redis.DequeueItemFromList(key);
            }
    /// <summary>
            /// 将指定ListId的List<T>队尾的那个元素出列，区别是：会阻塞该List<T>，支持超时时间，返回出列元素
            /// 它是命令 LPOP 的阻塞版本，这是因为当给定列表内没有任何元素可供弹出的时候， 连接将被 BLPOP 命令阻塞。
            /// 原指令：BLPOP key [key ...] timeout
            /// 时间复杂度：O(1)
            /// 参考:http://www.redis.cn/commands/blpop.html
            /// </summary>  
            public string BlockingDequeueItemFromList(string key, TimeSpan? sp)
            {
                return Redis.BlockingDequeueItemFromList(key, sp);
            }
    
            /// <summary>
            /// 将指定ListId[]的List<T>末尾的那个元素出列，区别是：会阻塞该List<T>，支持超时时间，返回出列元素
            /// </summary>
            /// <param name="keys"></param>
            /// <param name="sp"></param>
            /// <returns></returns>
            public ItemRef BlockingDequeueItemFromLists(string[] keys, TimeSpan? sp)
            {
                return Redis.BlockingDequeueItemFromLists(keys, sp);
            }

4、获取

/// <summary>
            /// 返回存储在 key 里的list的长度。 如果 key 不存在，那么就被看作是空list，并且返回长度为 0。 
            /// 当存储在 key 里的值不是一个list的话，会返回error。
            /// 原指令：LLEN key
            /// 时间复杂度：O(1)
            /// 参考：http://www.redis.cn/commands/llen.html
            /// </summary>  
            public long Count(string key)
            {
                return Redis.GetListCount(key);
            }
    
            /// <summary>
            /// 获取key包含的所有数据集合
            /// </summary>  
            public List<string> Get(string key)
            {
                return Redis.GetAllItemsFromList(key);
            }
            /// <summary>
            /// 获取key中下标为star到end的值集合
            /// 返回存储在 key 的列表里指定范围内的元素。 start 和 end 偏移量都是基于0的下标，即list的第一个元素下标是0（list的表头），第二个元素下标是1，以此类推。
            /// 偏移量也可以是负数，表示偏移量是从list尾部开始计数。 例如， -1 表示列表的最后一个元素，-2 是倒数第二个，以此类推。
            /// 原指令：LRANGE key start stop
            /// 时间复杂度：O(S+N)
            /// 参考：http://www.redis.cn/commands/lrange.html
            /// </summary>  
            public List<string> Get(string key, int star, int end)
            {
                return Redis.GetRangeFromList(key, star, end);
            }

5、删除

/// <summary>
            /// 从尾部移除数据，返回移除的数据
            /// </summary>  
            public string PopItemFromList(string key)
            {
                return Redis.PopItemFromList(key);
            }
            /// <summary>
            /// 从list的尾部移除一个数据，返回移除的数据
            /// 和PopItemFromList貌似差不多
            /// </summary>  
            public string RemoveEndFromList(string key)
            {
                return Redis.RemoveEndFromList(key);
            }
    
            /// <summary>
            /// 移除list中，key/value,与参数相同的值，并返回移除的数量
            /// </summary>  
            public long RemoveItemFromList(string key, string value)
            {
                return Redis.RemoveItemFromList(key, value);
            }
            /// <summary>
            /// 从list的头部移除一个数据，返回移除的值
            /// </summary>  
            public string RemoveStartFromList(string key)
            {
                return Redis.RemoveStartFromList(key);
            }