Aoite 系列(03) - 一起来 Redis 吧！

迷南。 2021-12-22 07:55 181阅读 0赞

> Aoite 是一个适于任何 .Net Framework 4.0+ 项目的快速开发整体解决方案。Aoite.Data 适用于市面上大多数的数据库提供程序，通过统一封装，可以在日常开发中简单便捷的操作数据库。

赶紧加入 **[Aoite GitHub][]** 的大家庭吧！！

插几句话：开源对我来讲，是一种分享。没有人可以从中获取金钱上的利益。每一套框架都有不足和亮点所在。Aoite 目的是让园友多一种可尝试的选择。对我来说的根本目的在于让 Aoite 真正的成为一个**快速开发整体解决方案**。

# 1. 快速入门 #

Redis 在 .NET 上有非常多成熟的框架。Aoite.Redis 仅仅目前只是实现其中的一员。实现 Aoite.Redis 的根本目的是为了迎合 Aoite.CommandModel 模块，并且减少对外部框架的依赖。

using(var client = new RedisClient(6379, null /* password*/))
    {
        client.FlushAll();
        client.Set("Int32Value", 1);
        client.Set("StringValue", "a");
        client.Set("DoubleValue", 1.0);
        client.Set("DecimalValue", 1.0m);
        client.Set("AnonymousValue", new BinaryValue(new { A = "a" }));
    
        Console.WriteLine((Int32)client.Get("Int32Value"));
        Console.WriteLine((String)client.Get("StringValue"));
        Console.WriteLine((Double)client.Get("DoubleValue"));
        Console.WriteLine((Decimal)client.Get("DecimalValue"));
        Console.WriteLine(client.Get("AnonymousValue").ToModel());
    }

### 1.1 二进制值 BinaryValue ###

`System.BinaryValue` 是一个非常有趣的类。它提供了从 decimal、Guid、string、DateTime、DateTimeOffset、TimeSpan、bool、ulong、char、uint、double、ushort、short、float、int 和 long 与 byte\[\] 之间的隐式转换。

比如你可以这么写：

BinaryValue value1 = 5;
    BinaryValue value2 = "abc";
    
    int x = value1;
    string y = value2;

当然了，对于复杂的类型，就必须通过构造函数来创建。

BinaryValue value = new BinaryValue(new { Username = "username", Passowrd = "passowrd" });
     Console.WriteLine(value.ToModel());

`ToModel` 还提供了一个泛型，可以执行返回值的数据类型。

不过，当遇见一个你无法预期判断出具体类型时，你可以这么做：

static void Print<T>(T obj)
    {
        BinaryValue value = BinaryValue.Create(obj);
        Console.WriteLine(value.Parse(typeof(T)));
    }

然后你就可以像这样调用：

Print("a");
    Print(1);
    Print(new { Username = "username", Passowrd = "passowrd" });

相信看到这里的你，应该就明白 `System.BinaryValue` 在 Redis 中可发挥的重大作用了。

### 1.2 事务 ###

Redis 的事务不同于关系型数据库的事务。在事务范围内的任何命令，都只会返回一个内容“QUENED”，表示此命令已成功加入命令列表（但不代表执行一定会成功）。所以在 Redis 上的事务，我们要一种**稍微奇怪**的方式进行。

你看见的代码，可能是这样的：

using(var client = new RedisClient(6379, null /* password*/))
    {
        using(var tran = client.BeginTransaction())
        {
            tran.On(tran.Set("key1", "value1"), r =>
            {
                Console.WriteLine("设置 Key1 为 value1 的结果是 {0}", r);
            });
            tran.On(tran.IncrBy("key2"), r =>
            {
                Console.WriteLine(r);
            });
            tran.Commit();
        }
        Console.WriteLine((string)client.Get("key1"));
        Console.WriteLine((string)client.Get("key2"));//- 根据 Redis 的协议，返回应该是 String 类型，而不是 Int64
    }

### 1.3 Hash 的改进 ###

如果有一个对象，你想存储在 Redis 中时，是以字段进行存储的，那就需要用到 Redis 的 HASH。

class MyModel
    {
        public string Username { get; set; }
        public string Password { get; set; }
    }

以下代码将 `MyModel` 存储到 Hash 中、从 Hash 获取所有域和获取部分域：

using(var client = new RedisClient(6379, null /* password*/))
    {
        client.FlushAll();
        string key = "model001";
        client.HMSet(key, new MyModel() { Username = "admin", Password = "123456" });
        var model = client.HGetAll<MyModel>(key);
        Console.WriteLine("Model -> {0}\t{1}", model.Username, model.Password);
    
        Console.WriteLine("Username : {0}", client.HGet(key, "Username"));
        Console.WriteLine("Password : {0}", client.HGet(key, "Password"));
    }

上面的代码输出：

Model -> admin  123456
    Username : admin
    Password : 123456

### 1.4 Scan Redis 的扫描 ###

Redis 中有 SCAN、HSCAN、SSCAN 和 ZSCAN 四个扫描的命令。Aoite.Redis 针对扫描的命令进行封装，返回一个 `IEnumerable<T>` 类型。**扫描的过程并不是一次性全部加载。**而是充分利用 `yield` 进行懒加载，第一次扫描至多返回 10 条数据（可以干涉需要返回的数量），再填充到 `Queue` 先进先出的队列中。等到队列中没有数据时，再重新扫描至多 10 条数据。直至扫描的队列为空并且下一批扫描的数据，整个扫描结束。

**Scan**：返回类型 `IEnumerable<string>`，以下代码输出内容： **11**（1,10,11,12...18,19）。

static void Code7()
    {
        using(var client = new RedisClient(6379, null /* password*/))
        {
            client.FlushAll();
            for(int i = 0; i < 20; i++)
            {
                client.Set("key" + i, "Value" + i);
            }
            Console.WriteLine(client.Scan(pattern: "key1*").Count());
        }
    }

**HScan**：返回类型 `IEnumerable<RedisFieldItem>`。

using(var client = new RedisClient(6379, null /* password*/))
    {
        client.FlushAll();
        for(int i = 0; i < 20; i++)
        {
            client.HSet("Key", "Field" + i, "Value" + i);
        }
        Console.WriteLine("[Field]\t|\t[Value]");
        foreach(var item in client.HScan("Key", pattern: "Field1*"))
        {
            Console.WriteLine("{0}\t|\t{1}",item.Field, item.Value);
        }
    }

以上代码输出：

**SScan**：返回类型 `IEnumerable<BinaryValue>`，以下代码输出内容 **5**。

using(var client = new RedisClient(6379, null /* password*/))
    {
        client.FlushAll();
        for(int i = 0; i < 20; i++)
        {
            client.SAdd("Key", "Member" + i % 5);
        }
        Console.WriteLine(client.SScan("Key").Count());
    }

**ZAdd**：返回类型 `IEnumerable<RedisScoreItem>`，代码可以参考 **HScan**。

### 1.5 哪些命令还没有被实现？ ###

**String 未实现命令**

*  [BITCOUNT][]
 *  [BITOP][]
 *  [GETBIT][]
 *  [SETBIT][]
 *  [SETEX][] 、[PSETEX][SETEX]、[SETNX][]：因为 [SET][] 命令可以通过参数来实现这三个命令的效果。

**Key 未实现命令**

*  [MIGRATE][]
 *  [OBJECT][]
 *  [DUMP][]
 *  [RESTORE][]

**Pub/Sub 未实现命令**

*  所有命令等找到合适的方式再去实现。

**Connection**

*  [ECHO][]

**Server**

*  [ClientPause][]
 *  [Monitor][]
 *  [DEBUG OBJECT][]
 *  [DEBUG SEGFAULT][]
 *  [ROLE][]
 *  [SHUTDOWN][]
 *  [PSYNC][]
 *  [SLAVEOF][]
 *  [SLOWLOG][]
 *  [SYNC][]
 *  [TIME][]

**隐式实现的命令**

*  `Transaction`，事务性命令通过 `IRedisClient.BeginTransaction` 来隐士完成。
    
     *  [DISCARD][]
     *  [EXEC][]
     *  [MULTI][]
 *  `Connection`
    
     *  [AUTH][]：初始化 RedisClient 就应该提供 Redis 的密码，来简化整体的流程。

## 3. 序列化 ##

Aoite.Serialization 里有包含两个部分内容。

*  继承 `System.Serializer` 的序列化器。比如已实现好的：`System.Serializer.Binary`、`System.Serializer.Json` 和 `System.Serializer.Xml`，当然还有本节的主角 \`System.Serializer.Quickly'。
 *  一套二进制的序列化组件 `Aoite.Serialization.ObjectWriter` 和 `ObjectReader`。这是一套针对字段级别的序列化，支持的类型非常多，Aoite.Tests 里有一个非常复杂的测试对象，想要了解它支持的类型，可以通过那个单元测试进行了解。

### 3.1 快速入门 ###

我们定义一个稍微有一丝丝复杂的对象：

class Dict2 : Dictionary<string, object>
    {
        public string MyProperty { get; set; }
    }

然后我们可以这么序列化和反序列化：

Dict2 dict = new Dict2() { MyProperty = "Hello" };
    dict.Add("1", new { A = "a" });
    dict.Add("2", "haha");
    dict.Add("3", 3);
    dict.Add("4", new[] { 1, 2, 3, 4 });
    var bytes = Serializer.Quickly.FastWriteBytes(dict);
    Console.WriteLine("bytes length {0}", bytes.Length);
    
    var dict2 = Serializer.Quickly.FastReadBytes(bytes) as Dict2;
    
    foreach(var item in dict2)
    {
        Console.WriteLine("{0}\t\t{1}", item.Key, item.Value);
        if(item.Value is Array)
        {
            foreach(var value in item.Value as Array)
            {
                Console.Write(value);
                Console.Write(",");     
            }
        }
    }

### 3.2 序列化特殊对象 ###

在 `Aoite.Redis.RedisSessionState` 这个特殊类，有一个数据类型为 `SessionStateItemCollection` 的特殊属性，这个通过 Quickly 的序列化是没有问题的，但是在使用时，便会抛出内存错误，具体什么原因我是没有深入研究。所以，针对无法序列化的对象，特性 `SerializableUsage` 便排上用场。

class RedisSessionState
    {
        //...
        [SerializableUsage(typeof(Serializable))]
        public SessionStateItemCollection Items { get; set; }
        //...
    
        class Serializable : Aoite.Serialization.ICustomSerializable
        {
            public object Deserialize(ObjectReader reader)
            {
                SessionStateItemCollection items = new SessionStateItemCollection();
                var count = reader.ReadInt32();
                for(int i = 0; i < count; i++)
                {
                    var name = (string)reader.Deserialize();
                    var value = reader.Deserialize();
                    items[name] = value;
                }
                return items;
            }
    
            public void Serialize(ObjectWriter writer, object value)
            {
                var items = value as SessionStateItemCollection;
                writer.InnerWrite(items.Count);
                foreach(string name in items.Keys)
                {
                    writer.Serialize(name);
                    writer.Serialize(items[name]);
                }
            }
        }
    
    }

`SerializableUsage` 特性指定一个类型，这样序列化器在处理过程中，将会初始化这个类型的实例，并调用 `Serialize` 或 `Deserialize` 方法。

这样，理论上任何对象都可以序列化为文本。当然了，如果你想序列化 `System.Windows.Forms.Form`（这个还是有办法的） 或者 `System.Web.Page` 这就比较难了……

## 4. 结束 ##

关于 Aoite.Ioc 和 Aoite.Serialization 的简单介绍，就到此结束了，如果你喜欢这个框架，不妨点个推荐吧！如果你非常喜欢这个框架，那请顺便到[Aoite GitHub][] Star 一下 ：）

转载于:https://www.cnblogs.com/sofire/p/aoite\_redis.html

[Aoite GitHub]: https://github.com/treenew/Aoite
[BITCOUNT]: http://redisdoc.com/string/bitcount.html
[BITOP]: http://redisdoc.com/string/bitop.html
[GETBIT]: http://redisdoc.com/string/getbit.html
[SETBIT]: http://redisdoc.com/string/setbit.html
[SETEX]: http://redisdoc.com/string/psetex.html
[SETNX]: http://redisdoc.com/string/setnx.html
[SET]: http://redisdoc.com/string/set.html
[MIGRATE]: http://redisdoc.com/key/migrate.html
[OBJECT]: http://redisdoc.com/key/object.html
[DUMP]: http://redisdoc.com/key/dump.html
[RESTORE]: http://redisdoc.com/key/restore.html
[ECHO]: http://redisdoc.com/connection/echo.html
[ClientPause]: http://redis.io/commands/client-pause
[Monitor]: http://redisdoc.com/server/monitor.html
[DEBUG OBJECT]: http://redisdoc.com/server/debug_object.html
[DEBUG SEGFAULT]: http://redisdoc.com/server/debug_segfault.html
[ROLE]: http://redis.io/commands/Role
[SHUTDOWN]: http://redisdoc.com/server/shutdown.html
[PSYNC]: http://redisdoc.com/server/psync.html
[SLAVEOF]: http://redisdoc.com/server/slaveof.html
[SLOWLOG]: http://redisdoc.com/server/slowlog.html
[SYNC]: http://redisdoc.com/server/sync.html
[TIME]: http://redisdoc.com/server/time.html
[DISCARD]: http://redisdoc.com/transaction/discard.html
[EXEC]: http://redisdoc.com/transaction/exec.html
[MULTI]: http://redisdoc.com/transaction/multi.html
[AUTH]: http://redisdoc.com/connection/auth.html