安装 StackExchange.Redis

使用教程 - 图1

引用及初始化

  • 引用
  1. using StackExchange.Redis;
  2. using Newtonsoft.Json;
  • 初始化 redis
  1. ConnectionMultiplexer _conn = RedisConnectionHelp.Instance;//初始化
  2. var database = _conn.GetDatabase(0);//指定连接的库 0

String（字符串）

String 是最常用的一种数据类型，普通的 key/value 存储都可以归为此类 。

一个 Key 对应一个 Value，string 类型是二进制安全的。Redis 的 string 可以包含任何数据，比如 jpg 图片(生成二进制)或者序列化的对象。

  1. database.StringSet("name", "苍");//设置StringSet(key, value)
  2. string str = database.StringGet("name");//结果：苍
  3. database.StringSet("name_two", str, TimeSpan.FromSeconds(10));//设置时间，10s后过期。
  • 存对象（对象需要序列化转成字符串，再存进库中）,取对象（反序列化）
  1. //创建对象
  2. Demo demo = new Demo()
  3. {
  4.     Name = "苍",
  5.     Age = 18,
  6.     Height = 1.83
  7. };
  8. string demojson = JsonConvert.SerializeObject(demo);//序列化
  9. database.StringSet("model", demojson);
  11. string model = database.StringGet("model");
  12. demo = JsonConvert.DeserializeObject<Demo>(model);//反序列化
  • StringIncrement 增量、StringDecrement 减量（默认值同为1）
  1. double increment = 0;
  2. double decrement = 0;
  3. for (int i = 0; i < 3; i++)
  4. {
  5.     increment = database.StringIncrement("StringIncrement", 2);//增量,每次+2
  6. }
  7. for (int i = 0; i < 3; i++)
  8. {
  9.     decrement = database.StringDecrement("StringIncrement");//减量，每次-1
  10. }

List（列表）

Redis 列表是简单的字符串列表，按照插入顺序排序。你可以添加一个元素到列表的头部或者尾部。

一个列表最多可以包含 232 - 1 个元素 （4294967295, 每个列表超过 40 亿个元素）。

  1. for (int i = 0; i < 10; i++)
  2. {
  3.     database.ListRightPush("list", i);//从底部插入数据
  4. }
  5. for (int i = 10; i < 20; i++)
  6. {
  7.     database.ListLeftPush("list", i);//从顶部插入数据
  8. }
  9. var length = database.ListLength("list");//长度 20
  11. var rightPop = database.ListRightPop("list");//从底部拿出数据
  13. var leftpop = database.ListLeftPop("list");//从顶部拿出数据
  15. var list = database.ListRange("list");

使用教程 - 图2

Hash（哈希）

Redis hash 是一个 string 类型的 field 和 value 的映射表，hash 特别适合用于存储对象。相对于将对象的每个字段存成单个 string 类型。一个对象存储在 hash 类型中会占用更少的内存，并且可以更方便的存取整个对象。

Redis 中每个 hash 可以存储 232 - 1 键值对（40多亿）。

Hash 的存储，给我的感觉类似于关系型数据库。以下面的例子为例，存储一个 user 对象（关系型数据库里的表名）， cang、shan、yun （关系型数据库里的数据的主键、唯一值），json（字段）

  1. string json = JsonConvert.SerializeObject(demo);//序列化
  2. database.HashSet("user", "cang", json);
  3. database.HashSet("user", "shan", json);
  4. database.HashSet("user", "yun", json);
  6. //获取Model
  7. string hashcang = database.HashGet("user", "cang");
  8. demo = JsonConvert.DeserializeObject<Demo>(hashcang);//反序列化
  10. //获取List
  11. RedisValue[] values = database.HashValues("user");//获取所有value
  12. IList<Demo> demolist = new List<Demo>();
  13. foreach (var item in values)
  14. {
  15.     Demo hashmodel = JsonConvert.DeserializeObject<Demo>(item);
  16.     demolist.Add(hashmodel);
  17. }

发布订阅

Redis 发布订阅 (pub/sub) 是一种消息通信模式，可以用于消息的传输，Redis 的发布订阅机制包括三个部分，发布者，订阅者和 Channel。适宜做在线聊天、消息推送等。

发布者和订阅者都是 Redis 客户端，Channel 则为 Redis 服务器端，发布者将消息发送到某个的频道，订阅了这个频道的订阅者就能接收到这条消息，客户端可以订阅任意数量的频道。

使用教程 - 图3

  1. ISubscriber sub = _conn.GetSubscriber();
  3. //订阅 Channel1 频道
  4. sub.Subscribe("Channel1", new Action<RedisChannel, RedisValue>((channel, message) =>
  5. {
  6.     Console.WriteLine("Channel1" + " 订阅收到消息：" + message);
  7. }));
  9. for (int i = 0; i < 10; i++)
  10. {
  11.     sub.Publish("Channel1", "msg" + i);//向频道 Channel1 发送信息
  12.     if (i == 2)
  13.     {
  14.         sub.Unsubscribe("Channel1");//取消订阅
  15.     }
  16. }

因为当 i == 2 的时候取消订阅，所以收到的订阅消息只有3条。

使用教程 - 图4

事务

事物开启后，会在调用 Execute 方法时把相应的命令操作封装成一个请求发送给 Redis 一起执行。

这里通过 CreateTransaction 函数（multi）来创建一个事物，调用其 Execute 函数（exec）提交事物。

其中的 “Condition.StringEqual(“name”, name)” 就相当于 Redis 命令中的 watch name。

  1. string name = database.StringGet("name");
  2. string age = database.StringGet("age");
  3. var tran = database.CreateTransaction();//创建事物
  4. tran.AddCondition(Condition.StringEqual("name", name));//乐观锁
  5. tran.StringSetAsync("name", "海");
  6. tran.StringSetAsync("age", 25);
  7. database.StringSet("name", "Cang");//此时更改 name 值，提交事物的时候会失败。
  8. bool committed = tran.Execute();//提交事物，true成功，false回滚。

因为提交事物的过程中，name 值被修改，所以造成了回滚，所有给 name 赋值海，age 赋值25都失败了。

Batch 批量操作

batch 会把所需要执行的命令打包成一条请求发到 Redis，然后一起等待返回结果。减少网络开销。

  1. var batch = database.CreateBatch();
  3. //批量写
  4. Task t1 = batch.StringSetAsync("name", "羽");
  5. Task t2 = batch.StringSetAsync("age", 22);
  6. batch.Execute();
  7. Task.WaitAll(t1, t2);
  8. Console.WriteLine("Age:" + database.StringGet("age"));
  9. Console.WriteLine("Name:" + database.StringGet("name"));
  11. //批量写
  12. for (int i = 0; i < 100000; i++)
  13. {
  14.     batch.StringSetAsync("age" + i, i);
  15. }
  16. batch.Execute();
  18. //批量读
  19. List<Task<RedisValue>> valueList = new List<Task<RedisValue>>();
  20. for (int i = 0; i < 10000; i++)
  21. {
  22.     Task<RedisValue> tres = batch.StringGetAsync("age" + i);
  23.     valueList.Add(tres);
  24. }
  25. batch.Execute();
  26. foreach (var redisValue in valueList)
  27. {
  28. string value = redisValue.Result;//取出对应的value值
  29. }

Lock（分布式锁）

由于 Redis 是单线程模型，命令操作原子性，所以利用这个特性可以很容易的实现分布式锁。

  1. RedisValue token = Environment.MachineName;
  2. //lock_key表示的是redis数据库中该锁的名称，不可重复。
  3. //token用来标识谁拥有该锁并用来释放锁。
  4. //TimeSpan表示该锁的有效时间。10秒后自动释放，避免死锁。
  5. if (database.LockTake("lock_key", token, TimeSpan.FromSeconds(10)))
  6. {
  7.     try
  8.     {
  9.         //TODO:开始做你需要的事情
  10.         Thread.Sleep(5000);
  11.     }
  12.     finally
  13.     {
  14.         database.LockRelease("lock_key", token);//释放锁
  15.     }
  16. }