Redis实战

List

Redis的List是通过Linked List（链表）来实现的String集合，所以插入数据的速度很快。

但是缺点就是在数据量比较大的时候，访问某个数据的时间可能会很长，但针对这种情况，可以使用Sorted Set，这个一会再说。

LPUSH，RPUSH，LRANGE

LPUSH会向List的左侧（头部）添加一个新的元素，而RPUSH会把新的元素添加到List的右侧（尾部）。

LRANGE命令可以按索引区间显示List的一部分，它的个试试LRANGE List-Key start end。如果想显示整个list的话，这两个索引就可以是0和-1，其中-1就表示最后一个元素。

注意：这里插入多个数，因为是链表，所以向左插入。

LPOP，RPOP

POP动作有两个效果：一个是获取到元素，另一个是把元素从list中删除。

LPOP就是从左边（头部）POP，RPOP就是从右边（尾部）POP。

LTRIM

LTRIM命令可以对list进行剪切，其格式为LTRIM list-key start end，返回的就是剪切的部分：

BRPOP，BLPOP

BRPOP和BLPOP这两个命令与RPOP和LPOP类似，但是当list里没有元素的时候，它们可以几秒钟，如果这期间有新的元素添加到了list里，那么就会停止等待返回该元素，否则就会一直等到设定的时间结束，然后返回null：

此外您还应该研究一下RPOPLPUSH和BRPOPLPUSH这两个命令。

.NET Core 操练LIST

static void List()
        {
            using (ConnectionMultiplexer redis = ConnectionMultiplexer.Connect("localhost:6379"))
            {

                IDatabase db = redis.GetDatabase();

                 db.KeyDelete("mylist"); //删除
                //LPUSH
                db.ListLeftPush("mylist","a");

                //RPUSH
                db.ListRightPush("mylist", new RedisValue[] {"a", "b", 5});

                //LRANGE
                var toDisplay = db.ListRange("mylist", 0, -1);

                foreach (RedisValue redisValue in toDisplay)
                {
                    Console.Write(redisValue+",");
                }
                //结果：a,a,b,5
                Console.WriteLine();
                
                //2.LPOP，RPOP 获取并删除
                Console.WriteLine("2.LPOP，RPOP 获取并删除");
                db.KeyDelete("mylist"); //删除
                db.ListLeftPush("mylist", new RedisValue[] {"a", "b", "c","d"});  //d,c,b,a
                
                RedisValue lpop =   db.ListLeftPop("mylist");
                Console.WriteLine(lpop); //结果：d

                RedisValue rpop = db.ListRightPop("mylist");
                Console.WriteLine(rpop); //结果：a

                //3.LTRIM 剪切
                 Console.WriteLine("3.LTRIM 剪切");
                db.KeyDelete("mylist"); //删除
                db.ListLeftPush("mylist", new RedisValue[] { "a", "b", "c", "d" });  //d,c,b,a

                db.ListTrim("mylist",0,1);

                var listtrim = db.ListRange("mylist", 0, -1);
               
                foreach (RedisValue redisValue in listtrim)
                {
                    Console.Write(redisValue + ",");
                }
                //结果：d,c
                Console.WriteLine();
            }
        }

SET

Redis的SET是无序的String集合，它里面的元素是不会重复的。

SADD

可以看到一次性可以添加一个或多个元素。

SMEMBERS

SMEMBERS可以获取set里所有的元素：

SISMEMBER

SISMEMBER可以判断某个元素是否在set里：

返回1表示true，0表示false。

SINTER

SINTER可以查看多个set之间的交集：

SPOP

SPOP可以随机从set中移除一个或多个元素并返回：

SUNION

SUNION key1 [key2] 

返回所有给定集合的并集

SUNIONSTORE

并集：把多个set合并到一个set里可以使用SUNIONSTORE，格式是sunionstore 目标set set1 set2 ...：

复制

如果只有一个set需要合并的话，那么就相当于是复制：

SCARD

SCARD可以获取set的大小：

SRANDMEMBER

SRANDMEMBER可以随机获取set里面的元素，但是不会移除它们：

.NET Core 操练SET

		static void SET()
        {
            using (ConnectionMultiplexer redis = ConnectionMultiplexer.Connect("localhost:6379"))
            {
                //1.SADD 添加
                IDatabase db = redis.GetDatabase();
                db.KeyDelete("set0");
                db.SetAdd("set0", new RedisValue[]{0,1,1,2,2,3,4,5,6,"1"}); 
                
                //2.SMEMBERS 查询所有
                var set0 = db.SetMembers("set0");
                string value = string.Empty;
                foreach (RedisValue redisValue in set0)
                {
                    value += redisValue + ",";
                }
                string remove = value.TrimEnd(','); 
                Console.WriteLine(remove);
                //结果：0，1，2，3，4，5，6 不会添加重复,这里添加了2个1，2个2，结果只添加上1个，原因？

                //3.SISMEMBER 可以判断某个元素是否在set里
                var result = db.SetContains("set0", "3");
                var result1 = db.SetContains("set0", "111");
                Console.WriteLine(result); //true
                Console.WriteLine(result1); //false

                //4.SINTER 查看多个set之间的交集
                db.KeyDelete(new RedisKey[] {"set1", "set2", "set3"});
                db.SetAdd("set1", new RedisValue[] {0, 1, 1, 2, 2, 3, 4, 5, 6});
                db.SetAdd("set2", new RedisValue[] { 1, 3, 5, 7,9});
                db.SetAdd("set3", new RedisValue[] {1, 5, 9,11});
                var intersection = db.SetCombine(SetOperation.Intersect, new RedisKey[] {"set1", "set2", "set3"});
                string valueCombine = string.Empty;
                foreach (RedisValue redisValue in intersection)
                {
                    valueCombine += redisValue + ",";
                }
                string removeCombine = valueCombine.TrimEnd(',');
                Console.WriteLine(removeCombine); 
                //结果：1，5

                //5.SPOP 随机从set中移除一个或多个元素并返回
                // var pop1 = db.SetPop("set0");
                // var pop2 = db.SetPop("set0");
                // var pop3 = db.SetPop("set0");
                // Console.WriteLine(pop1);
                // Console.WriteLine(pop2);
                // Console.WriteLine(pop3);
                //结果：6,4,5

                //6.SUNIONSTORE 并集：把多个set合并到一个set里可以使用SUNIONSTORE，格式是sunionstore 目标set set1 set2 ...：
                //这里第2个参数的“targetset”，是目标集的key（新合成的key）
                var size = db.SetCombineAndStore(SetOperation.Union,"targetset", new RedisKey[] {"set1", "set2", "set3"});
                Console.WriteLine(size);  //10

                //7.SCARD 可以获取set的大小：
                var scardSize = db.SetLength("set0");
                Console.WriteLine(scardSize); // 7 = (0,1,2,3,4,5,6).length

                //8.SRANDMEMBER 可以随机获取set里面的元素，但是不会移除它们
                var random = db.SetRandomMember("set0");
                Console.WriteLine(random); //4
            } 
        }

Sorted SET

Sorted Set有点像Set和Hash的结合体。

和Set一样，它里面的元素是唯一的，类型是String，所以它可以理解为就是一个Set。

但是Set里面的元素是无序的，而Sorted Set里面的元素都带有一个浮点值，叫做分数（score），所以这一点和Hash有点像，因为每个元素都映射到了一个值。

Sorted Set是有序的，规则如下：

• 如果A.score > B.score，那么A > B。
• 如果A.score == B.score，那么A和B的大小就通过比较字符串来决定了，而A和B的字符串是不会相等的，因为Sorted Set里面的值都是唯一的。

ZADD

ZADD可以添加元素到Sorted Set，就和Set的SADD命令差不多：

可以看到ZADD的格式是：zadd key score element。

ZRANGE，ZREVRANGE

ZRANGE默认按分数由低到高把Sorted Set的元素显示出来：
ZREVRANGE 从高到低：

也可以一同把分数显示出来，使用参数WITHSCORES：

ZRANGEBYSCORE

ZRANGEBYSCORE可以按范围显示Sorted Set，格式是zrangebyscore key 分数下限 分数上限：

ZREMRANGEBYSCORE

ZREMRANGEBYSCORE可以按范围移除元素：

该命令返回的是移除元素的个数。

其中-inf和inf分别表示负无穷和正无穷。

ZRANK

ZRANK命令可以获得元素的排名：

排名从0开始。

ZREVRANK

ZREVRANK这个正好和ZRANK相反，就不说了。

词典分数（分数相同）

Sorted Set里分数相同的元素是按照词典分数（可以理解为比较字符串）进行排序的。

ZRANGEBYLEX

ZRANGEBYLEX可以按词典范围展示Sorted Set：

ZREVRANGEBYLEX

ZREVRANGEBYLEX 返回指定成员区间内的成员，按成员字典倒序排序, 分数必须相同。
在某些业务场景中,需要对一个字符串数组按名称的字典顺序进行倒序排列时,可以使用Redis中SortSet这种数据结构来处理。
http://www.redis.cn/commands/zrevrangebylex.html

ZREMRANGEBYLEX

ZREMRANGEBYLEX 删除名称按字典由低到高排序成员之间所有成员。
不要在成员分数不同的有序集合中使用此命令, 因为它是基于分数一致的有序集合设计的,如果使用,会导致删除的结果不正确。
待删除的有序集合中,分数最好相同,否则删除结果会不正常。
http://www.redis.cn/commands/zremrangebylex.html

ZLEXCOUNT

ZLEXCOUNT 命令用于计算有序集合中指定成员之间的成员数量。
http://www.redis.cn/commands/zlexcount.html

.NET core操练Sorted Set

        static void SortSet()
        {
            using (ConnectionMultiplexer redis = ConnectionMultiplexer.Connect("localhost:6379"))
            {

                IDatabase db = redis.GetDatabase();
                //1.ZADD，ZRANGE 添加，ZRANGE排序：默认按分数由低到高把Sorted Set的元素显示出来：
                db.SortedSetAdd("players", "张三", 89d);
                db.SortedSetAdd("players", new SortedSetEntry[]
                {
                    new SortedSetEntry("李四",75d),
                    new SortedSetEntry("王五",78d),
                    new SortedSetEntry("赵六",91d),
                    new SortedSetEntry("钱七",100d),
                    new SortedSetEntry("孙八",50d),
                    new SortedSetEntry("李九",65d),
                    new SortedSetEntry("唐三三",88),
                });
                //ZRANGE
                var sortedSet = db.SortedSetRangeByRank("players", start: 0, stop: -1);
                foreach (RedisValue value in sortedSet)
                {
                    Console.WriteLine(value);
                }
                // 孙八
                // 李九
                // 李四
                // 王五
                // 唐三三
                // ....

                //2.ZREVRANGE，WITHSCORES
                //ZREVRANGE 从高到低：也可以一同把分数显示出来，使用参数WITHSCORES：
                var sortedSetWITHSCORES = db.SortedSetRangeByRankWithScores("players", start: 0, stop: -1,order:Order.Descending);
                foreach (SortedSetEntry value in sortedSetWITHSCORES)
                {
                    Console.WriteLine(value);
                }
                //钱七:100
                //赵六:91
                //张三:89
                //唐三三:88
                //王五:78
                // ....
                Console.WriteLine();
                
                //3.ZRANGEBYSCORE 可以按范围显示Sorted Set，格式是zrangebyscore key 分数下限 分数上限：
                var sortedSetZRANGEBYSCORE = db.SortedSetRangeByScoreWithScores("players", start: 60, stop: 90);
                foreach (SortedSetEntry value in sortedSetZRANGEBYSCORE)
                {
                    Console.WriteLine(value);
                }
                // 李九：65
                // 李四：75
                // 王五：78
                // 唐三三：88
                // 张三:89
                 Console.WriteLine();

                //4.ZREMRANGEBYSCORE 可以按范围移除元素
                //double.NegativeInfinity:负无穷 (redis命令：-inf)
                var ZREMRANGEBYSCORE =
                    db.SortedSetRemoveRangeByScore("players", start: double.NegativeInfinity, stop: 60);
                var sortedSetfor = db.SortedSetRangeByScoreWithScores("players", start: Double.MinValue, stop: Double.MaxValue);
                foreach (SortedSetEntry value in sortedSetfor)
                {
                    Console.WriteLine(value);
                }
                // 李九：65
                // 李四：75
                // 王五：78
                // 唐三三：88
                // 张三：89
                // 赵六：91
                // 钱七：100
                Console.WriteLine();

                //5.ZRANK 可以获得元素的排名
                var rank = db.SortedSetRank("players", "唐三三");
                Console.WriteLine(rank); //3

                //6.ZRANGEBYLEX 可以获得元素的排名，高到低
                db.KeyDelete("players");
                db.SortedSetAdd("players", new SortedSetEntry[]
                {
                    new SortedSetEntry("Alan smith",0),
                    new SortedSetEntry("Chuck Van Halen",0),
                    new SortedSetEntry("Filippo Inzaghi",0),
                    new SortedSetEntry("Michael Jackson",0),
                    new SortedSetEntry("Di Matteo",0),
                    new SortedSetEntry("Charlie Sheen",0),
                    new SortedSetEntry("Eric Evans",0),
                });

                var ZRANGEBYLEX = db.SortedSetRangeByValue("players", "C", "F");
                foreach (var value in ZRANGEBYLEX)
                {
                    Console.WriteLine(value);
                }
                // Charlie Sheen
                // Chuck Uan Halen
                // Di Matteo
                // Eric Evans

                db.KeyDelete("players");
                db.SortedSetAdd("players", new SortedSetEntry[]
                {
                    new SortedSetEntry("李四",75d),
                    new SortedSetEntry("王五",78d),
                    new SortedSetEntry("赵六",91d),
                    new SortedSetEntry("钱七",100d),
                    new SortedSetEntry("孙八",50d),
                    new SortedSetEntry("李九",65d),
                    new SortedSetEntry("唐三三",88),
                });

                var ZRANGEBYLEX1 = db.SortedSetRangeByValue("players", "C", "F");
                foreach (var value in ZRANGEBYLEX1)
                {
                    Console.WriteLine(value);
                }
                //中文为null
            }
        }

参考：

草根专栏，Redis in .NET Core 入门：(4) LIST和SET
草根专栏，Redis in .NET Core 入门：(5) Sorted SET
杨旭(Video)，Redis in ASP.NET Core 3. List, Set, Sorted Set