C#使用Flatbuffer数据格式传输大批量数据完整示例

FlatBuffers 是谷歌开源的多语言序列化工具库,常用语言C ++、C＃、C、Go、Java、PHP、Python 和 JavaScript等都支持。

和目前主流的Json相比，没有字段名等的重复数据，同样的数据可以极大的减少传输量，反序列化速度极快，非常适用于传输数据量大的数据。

缺点是数据构造麻烦，可读性差，但是对于可观的的传输效率提升，开发成本也不算高。

下载工具

首先需要从GitHub下载源码和工具flatc.exe： https://github.com/google/flatbuffers/releases，解压下载的文件用于后续解析模板。

编写对应的Schema数据模板文件

支持的类型和数据结构可参考官方文档：https://google.github.io/flatbuffers/flatbuffers_guide_writing_schema.html
这里示例一个复杂的结构,保存为 test.fbs文件：

 //解析后生成的类包路径
namespace com.test;
//实体结构
table EntityQuantities{
    entities:[Entity];  //实体列表
    details:[Detail];   //明细列表
}
//实体数据
table Entity{
    name:string;    //名称
    children:[Entity]; //子级数据
    quantities:[EntityQuantity]; //数量列表 
}
//数量数据
table EntityQuantity{
    name:string;    //名称
    unit:string;    //单位
    quantity:double;    //数量
}
//明细
table Detail{
    parentIndex:[int];  //EntityQuantities中父级层级
    floorId:int;    //楼层
    handle:string;  //handle
    quantity:double;    //量
}
root_type  EntityQuantities;  //根实体

解析数据

把文件放在目录下（在其他目录下test.fbs需加上路径），在下载工具解压后的目录中CMD执行flatc.exe --csharp test.fbs解析文件，得到C#实体类加入项目中。

生成数据

注意FlatBuffers在生成数据时非数字类型需要提前计算偏移，最好严按照顺序计算每一级的偏移，否则容易出现问题。

            //新建构造类
            FlatBufferBuilder fb = new FlatBufferBuilder(1);
            //数据生成
            //EntityQuantities.entities偏移量
            List> entitiesOffset = new List>(10);
            //EntityQuantities.details偏移量
            List> detailsOffset = new List>(10);
            for (int i = 0; i < 10; i++)
            {
                //Entity.name 偏移量
                StringOffset nameOffset = fb.CreateString("构件类型" + i);
                //Entity.children 偏移量
                List> childrenOffset = new List>(5);
                for (int j = 0; j < 5; j++)
                {
                    //Entity.name 偏移量
                    StringOffset subNameOffset = fb.CreateString("子类型" + j);
                    VectorOffset cVectorOffset = Entity.CreateChildrenVector(fb, new Offset[0]);
                    //Entity.quantities 偏移量
                    List> quantitiesOffset = new List>(10);
                    for (int k = 0; k < 3; k++)
                    {
                        //EntityQuantity.name 名称 偏移量
                        StringOffset enameOffset = fb.CreateString("构件名称" + k);
                        //EntityQuantity.unit 单位 偏移量
                        StringOffset eunitOffset = fb.CreateString("m");
                        //EntityQuantity.quantity 工程量
                        double quantity = i * j * k;
                        //EntityQuantity整体偏移量
                        Offset eqOff = EntityQuantity.CreateEntityQuantity(fb, enameOffset, eunitOffset, quantity);
                        quantitiesOffset.Add(eqOff);
                        for (int l = 0; l < 2; l++)
                        {
                            //Detail.parentIndex 父级下标 偏移量
                            VectorOffset indexVectorOffset = Detail.CreateParentIndexVector(fb, new int[] { i, j, k });
                            //Detail.floorId 名称 偏移量
                            int floorId = i + j + k + l;
                            //EntityQuantity.unit 单位 偏移量
                            StringOffset handleOffset = fb.CreateString("handle" + floorId);
                            //EntityQuantity.quantity 工程量
                            double qty = i * j * k * l;
                            //Detail整体偏移量
                            Offset dqOff = Detail.CreateDetail(fb, indexVectorOffset, floorId, handleOffset, qty);
                            detailsOffset.Add(dqOff);
                        }
                    }
                   //向上每级偏移量计算
                    VectorOffset qVectorOffset = Entity.CreateQuantitiesVector(fb, quantitiesOffset.ToArray());
                    Offset subOffset = Entity.CreateEntity(fb, subNameOffset, cVectorOffset, qVectorOffset);
                    childrenOffset.Add(subOffset);
                }
                VectorOffset cOffset = Entity.CreateChildrenVector(fb, childrenOffset.ToArray());
                VectorOffset qOffset = Entity.CreateQuantitiesVector(fb, new Offset[0]);
                Offset offset = Entity.CreateEntity(fb, nameOffset, cOffset, qOffset);
                entitiesOffset.Add(offset);
            }
            /根类偏移量计算
            Offset root = EntityQuantities.CreateEntityQuantities(fb,
                EntityQuantities.CreateEntitiesVector(fb, entitiesOffset.ToArray()),
                EntityQuantities.CreateDetailsVector(fb, detailsOffset.ToArray())
                );
            //构造数据
            fb.Finish(root.Value);
            //写入文件（前端对接直接返回字节流即可）
            using (var ms = fb.DataBuffer.ToMemoryStream(fb.DataBuffer.Position, fb.Offset))
            {
                File.WriteAllBytes("D://Data/test.flatbuffers", ms.ToArray());
            }

读取数据

            ByteBuffer bb = new ByteBuffer(File.ReadAllBytes("D://Data/test.flatbuffers"));
            EntityQuantities data = EntityQuantities.GetRootAsEntityQuantities(bb);
            Console.WriteLine("实体数：" + data.EntitiesLength);
            Console.WriteLine("详情数：" + data.DetailsLength);
            for (int i = 0; i < data.EntitiesLength; i++)
            {
                Entity entity = data.Entities(i).Value;
                Console.WriteLine("名称：" + entity.Name);
                Console.WriteLine("子类型数：" + entity.ChildrenLength);
            }
            for (int i = 0; i < data.DetailsLength; i++)
            {
                Detail entity = data.Details(i).Value;
                Console.WriteLine("详情：" + entity.Handle);
                Console.WriteLine("父级别数：" + entity.ParentIndexLength);
                for (int j = 0; j < entity.ParentIndexLength; j++)
                {
                    int index = entity.ParentIndex(j);
                    Console.Write(" " + index + ":");
                }
            }