[.NET]使用十年股价对比各种序列化技术
原文:[.NET]使用十年股价对比各种序列化技术
1. 前言
上一家公司有搞股票,当时很任性地直接从服务器读取一个股票10年份的股价(还有各种指标)在客户端的图表上显示,而且因为是桌面客户端,传输的数据也是简单粗暴地使用Soap序列化。获取报价的接口大概如下,通过symbol、beginDate和endDate三个参数获取股票某个时间段的股价:
public IEnumerable<StockPrice> LoadStockPrices(string symbol,DateTime beginDate,DateTime endDate)
{//some code
}
后来用Xamarin.Forms做了移动客户端,在手机上就不敢这么任性了,移动端不仅对流量比较敏感,而且显示这么多数据也不现实,于是限制为不可以获取这么长时间的股价,选择一种新的序列化方式也被提上了日程。不过当时我也快离职了所以没关心这件事。
上周看到这篇问文章:【开源】C#.NET股票历史数据采集,【附18年历史数据和源代码】,一时兴起就试试用各种常用的序列化技术实现以前的需求。
2. 数据结构
[Serializable]
[ProtoContract]
[DataContract]
public class StockPrice
{[ProtoMember(1)][DataMember]public double ClosePrice { get; set; }[ProtoMember(2)][DataMember]public DateTime Date { get; set; }[ProtoMember(3)][DataMember]public double HighPrice { get; set; }[ProtoMember(4)][DataMember]public double LowPrice { get; set; }[ProtoMember(5)][DataMember]public double OpenPrice { get; set; }[ProtoMember(6)][DataMember]public double PrvClosePrice { get; set; }[ProtoMember(7)][DataMember]public string Symbol { get; set; }[ProtoMember(8)][DataMember]public double Turnover { get; set; }[ProtoMember(9)][DataMember]public double Volume { get; set; }
}
上面是股价的数据结构,包含股票代号、日期、OHLC、前收市价(PreClosePice),成交额(Turnover)和成交量(Volume),这里我已经把序列化要用到的Attribute加上了。
测试数据使用長和(00001)2003年开始10年的股价,共2717条数据。为了方便测试已经把它们从数据库导出到文本文档。其实大小也就200K而已。
3. 各种序列化技术
在.NET中要执行序列化有很多可以考虑的东西,如网络传输、安全性、.NET Remoting的远程对象等内容。但这里单纯只考虑序列化本身。
3.1 二进制序列化
二进制序列化将对象的公共字段和私有字段以及类(包括含有该类的程序集)的名称都转换成字节流,对该对象进行反序列化时,将创建原始对象的准确克隆。除了.NET可序列化的类型,其它类型要想序列化,最简单的方法是使用 SerializableAttribute 对其进行标记。
.NET中使用BinaryFormatter实现二进制序列化,代码如下:
public override byte[] Serialize(List<StockPrice> instance)
{using (var stream = new MemoryStream()){IFormatter formatter = new BinaryFormatter();formatter.Serialize(stream, instance);return stream.ToArray();}
}public override List<StockPrice> Deserialize(byte[] source)
{using (var stream = new MemoryStream(source)){IFormatter formatter = new BinaryFormatter();var target = formatter.Deserialize(stream);return target as List<StockPrice>;}
}
结果:
Name | Serialize(ms) | Deserialize(ms) | Bytes |
---|---|---|---|
BinarySerializer | 117 | 12 | 242,460 |
3.2 XML
XML序列化将对象的公共字段和属性或者方法的参数及返回值转换(序列化)为符合特定 XML架构定义语言 (XSD) 文档的 XML 流。由于 XML 是开放式的标准,因此可以根据需要由任何应用程序处理 XML流,而与平台无关。
.NET中执行Xml序列化可以使用XmlSerializer:
public override byte[] Serialize(List<StockPrice> instance)
{using (var stream = new MemoryStream()){var serializer = new System.Xml.Serialization.XmlSerializer(typeof(List<StockPrice>));serializer.Serialize(stream, instance);return stream.ToArray();}
}public override List<StockPrice> Deserialize(byte[] source)
{using (var stream = new MemoryStream(source)){var serializer = new System.Xml.Serialization.XmlSerializer(typeof(List<StockPrice>));var target = serializer.Deserialize(stream);return target as List<StockPrice>;}
}
结果如下,因为XML格式为了有较好的可读性引入了一些冗余的文本信息,所以体积膨胀了不少:
Name | Serialize(ms) | Deserialize(ms) | Bytes |
---|---|---|---|
XmlSerializer | 133 | 26 | 922,900 |
3.3 SOAP
XML 序列化还可用于将对象序列化为符合 SOAP 规范的 XML 流。 SOAP 是一种基于 XML 的协议,它是专门为使用 XML 来传输过程调用而设计的,熟悉WCF的应该不会对SOAP感到陌生。
.NET中使用SoapFormatter实现序列化,代码如下:
public override byte[] Serialize(List<StockPrice> instance)
{using (var stream = new MemoryStream()){IFormatter formatter = new SoapFormatter();formatter.Serialize(stream, instance.ToArray());return stream.ToArray();}
}public override List<StockPrice> Deserialize(byte[] source)
{using (var stream = new MemoryStream(source)){IFormatter formatter = new SoapFormatter();var target = formatter.Deserialize(stream);return (target as StockPrice[]).ToList();}
}
结果如下,由于它本身的特性,体积膨胀得更可怕了(我记得WCF默认就是使用SOAP?):
Name | Serialize(ms) | Deserialize(ms) | Bytes |
---|---|---|---|
SoapSerializer | 105 | 123 | 2,858,416 |
3.4 JSON
JSON(JavaScript Object Notation)是一种由道格拉斯·克罗克福特构想和设计、轻量级的资料交换语言,该语言以易于让人阅读的文字为基础,用来传输由属性值或者序列性的值组成的数据对象。
虽然.NET提供了DataContractJsonSerializer,但Json.NET更受欢迎,代码如下:
public override byte[] Serialize(List<StockPrice> instance)
{using (var stream = new MemoryStream()){var serializer = new DataContractJsonSerializer(typeof(List<StockPrice>));serializer.WriteObject(stream, instance);return stream.ToArray();}
}public override List<StockPrice> Deserialize(byte[] source)
{using (var stream = new MemoryStream(source)){var serializer = new DataContractJsonSerializer(typeof(List<StockPrice>));var target = serializer.ReadObject(stream);return target as List<StockPrice>;}
}
结果如下,JSON的体积比XML小很多:
Name | Serialize(ms) | Deserialize(ms) | Bytes |
---|---|---|---|
JsonSerializer | 40 | 60 | 504,320 |
3.5 Protobuf
其实一开始我和我的同事就清楚用Protobuf最好。
Protocol Buffers 是 Google提供的数据序列化机制。它性能高,压缩效率好,但是为了提高性能,Protobuf采用了二进制格式进行编码,导致可读性较差。
使用protobuf-net需要将序列化的对象使用ProtoContractAttribute和ProtoMemberAttribute进行标记。序列化和反序列化代码如下:
public override byte[] Serialize(List<StockPrice> instance)
{using (var stream = new MemoryStream()){Serializer.Serialize(stream, instance);return stream.ToArray();}
}public override List<StockPrice> Deserialize(byte[] source)
{using (var stream = new MemoryStream(source)){return Serializer.Deserialize<List<StockPrice>>(stream);}
}
结果十分优秀:
Name | Serialize(ms) | Deserialize(ms) | Bytes |
---|---|---|---|
ProtobufSerializer | 93 | 18 | 211,926 |
3.6 结果对比
Name | Serialize(ms) | Deserialize(ms) | Bytes |
---|---|---|---|
BinarySerializer | 117 | 12 | 242,460 |
XmlSerializer | 133 | 26 | 922,900 |
SoapSerializer | 105 | 123 | 2,858,416 |
JsonSerializer | 40 | 60 | 504,320 |
ProtobufSerializer | 93 | 18 | 211,926 |
将上述方案的结果列出来对比,Protobuf序列化后体积最少。不过即使是Protobuf,压缩后的数据仍然比文本文档的200K还大,那还不如直接传输这个文本文档。
4. 优化数据结构
其实传输的数据结构上有很大的优化空间。
首先是股票代号Symbol,前面提到获取股价的接口大概是这样:IEnumerable LoadStockPrices(string symbol,DateTime beginDate,DateTime endDate)
。既然都知道要获取的股票代号,StockPrice中Symbol这个属性完全就是多余的。
其次是OHLC和PreClosePrice,港股(不记得其它Market是不是这样)的报价肯定是4位有效数字(如95.05和102.4),用float精度也够了,不必用 double。
最后是Date,反正只需要知道日期,不必知道时分秒,直接用与1970-01-01相差的天数作为存储应该就可以了。
private static DateTime _beginDate = new DateTime(1970, 1, 1);public DateTime Date
{get => _beginDate.AddDays(DaysFrom1970);set => DaysFrom1970 = (short) Math.Floor((value - _beginDate).TotalDays);
}[ProtoMember(2)]
[DataMember]
public short DaysFrom1970 { get; set; }
不要以为Volume可以改为int,有些仙股有时会有几十亿的成交量,超过int的最大值2147483647(顺便一提Int32的最大值是2的31次方减1,有时面试会考)。
这样修改后的类结构如下:
[Serializable]
[ProtoContract]
[DataContract]
public class StockPriceSlim
{[ProtoMember(1)][DataMember]public float ClosePrice { get; set; }private static DateTime _beginDate = new DateTime(1970, 1, 1);public DateTime Date{get => _beginDate.AddDays(DaysFrom1970);set => DaysFrom1970 = (short) Math.Floor((value - _beginDate).TotalDays);}[ProtoMember(2)][DataMember]public short DaysFrom1970 { get; set; }[ProtoMember(3)][DataMember]public float HighPrice { get; set; }[ProtoMember(4)][DataMember]public float LowPrice { get; set; }[ProtoMember(5)][DataMember]public float OpenPrice { get; set; }[ProtoMember(6)][DataMember]public float PrvClosePrice { get; set; }[ProtoMember(8)][DataMember]public double Turnover { get; set; }[ProtoMember(9)][DataMember]public double Volume { get; set; }
}
序列化的体积大幅减少:
Name | Serialize(ms) | Deserialize(ms) | Bytes |
---|---|---|---|
BinarySerializer | 11 | 12 | 141,930 |
XmlSerializer | 42 | 24 | 977,248 |
SoapSerializer | 48 | 89 | 2,586,720 |
JsonSerializer | 17 | 33 | 411,942 |
ProtobufSerializer | 7 | 3 | 130,416 |
其实之所以有这么大的优化空间,一来是因为传输的对象本身就是ORM生成的对象没针对网络传输做优化,二来各个券商的数据源差不多都是这样传输数据的,最后,本来这个接口是给桌面客户端用的根本就懒得考虑传输数据的大小。
5. 自定义的序列化
由于股票的数据结构相对稳定,而且这个接口不需要通用性,可以自己实现序列化。StockPriceSlim所有属性加起来是38个字节,测试数据是2717条报价,共103246字节,少于Protobuf的130416字节。要达到每个报价只存储38个字节,只需将每个属性的值填入固定的位置:
public override byte[] SerializeSlim(List<StockPriceSlim> instance)
{var list = new List<byte>();foreach (var item in instance){var bytes = BitConverter.GetBytes(item.DaysFrom1970);list.AddRange(bytes);bytes = BitConverter.GetBytes(item.OpenPrice);list.AddRange(bytes);bytes = BitConverter.GetBytes(item.HighPrice);list.AddRange(bytes);bytes = BitConverter.GetBytes(item.LowPrice);list.AddRange(bytes);bytes = BitConverter.GetBytes(item.ClosePrice);list.AddRange(bytes);bytes = BitConverter.GetBytes(item.PrvClosePrice);list.AddRange(bytes);bytes = BitConverter.GetBytes(item.Volume);list.AddRange(bytes);bytes = BitConverter.GetBytes(item.Turnover);list.AddRange(bytes);}return list.ToArray();
}public override List<StockPriceSlim> DeserializeSlim(byte[] source)
{var result = new List<StockPriceSlim>();var index = 0;using (var stream = new MemoryStream(source)){while (index < source.Length){var price = new StockPriceSlim();var bytes = new byte[sizeof(short)];stream.Read(bytes, 0, sizeof(short));var days = BitConverter.ToInt16(bytes, 0);price.DaysFrom1970 = days;index += bytes.Length;bytes = new byte[sizeof(float)];stream.Read(bytes, 0, sizeof(float));var value = BitConverter.ToSingle(bytes, 0);price.OpenPrice = value;index += bytes.Length;stream.Read(bytes, 0, sizeof(float));value = BitConverter.ToSingle(bytes, 0);price.HighPrice = value;index += bytes.Length;stream.Read(bytes, 0, sizeof(float));value = BitConverter.ToSingle(bytes, 0);price.LowPrice = value;index += bytes.Length;stream.Read(bytes, 0, sizeof(float));value = BitConverter.ToSingle(bytes, 0);price.ClosePrice = value;index += bytes.Length;stream.Read(bytes, 0, sizeof(float));value = BitConverter.ToSingle(bytes, 0);price.PrvClosePrice = value;index += bytes.Length;bytes = new byte[sizeof(double)];stream.Read(bytes, 0, sizeof(double));var volume = BitConverter.ToDouble(bytes, 0);price.Volume = volume;index += bytes.Length;bytes = new byte[sizeof(double)];stream.Read(bytes, 0, sizeof(double));var turnover = BitConverter.ToDouble(bytes, 0);price.Turnover = turnover;index += bytes.Length;result.Add(price);}return result;}
}
结果如下:
Name | Serialize(ms) | Deserialize(ms) | Bytes |
---|---|---|---|
CustomSerializer | 5 | 1 | 103,246 |
这种方式不仅序列化后的体积最小,而且序列化和反序列化的速度都十分优秀,不过代码十分难看而且没有扩展性。尝试用反射改进一下:
public override byte[] SerializeSlim(List<StockPriceSlim> instance)
{var result = new List<byte>();foreach (var item in instance)foreach (var property in typeof(StockPriceSlim).GetProperties()){if (property.GetCustomAttribute(typeof(DataMemberAttribute)) == null)continue;var value = property.GetValue(item);byte[] bytes = null;if (property.PropertyType == typeof(int))bytes = BitConverter.GetBytes((int)value);else if (property.PropertyType == typeof(short))bytes = BitConverter.GetBytes((short)value);else if (property.PropertyType == typeof(float))bytes = BitConverter.GetBytes((float)value);else if (property.PropertyType == typeof(double))bytes = BitConverter.GetBytes((double)value);result.AddRange(bytes);}return result.ToArray();
}public override List<StockPriceSlim> DeserializeSlim(byte[] source)
{using (var stream = new MemoryStream(source)){var result = new List<StockPriceSlim>();var index = 0;while (index < source.Length){var price = new StockPriceSlim();foreach (var property in typeof(StockPriceSlim).GetProperties()){if (property.GetCustomAttribute(typeof(DataMemberAttribute)) == null)continue;byte[] bytes = null;object value = null;if (property.PropertyType == typeof(int)){bytes = new byte[sizeof(int)];stream.Read(bytes, 0, bytes.Length);value = BitConverter.ToInt32(bytes, 0);}else if (property.PropertyType == typeof(short)){bytes = new byte[sizeof(short)];stream.Read(bytes, 0, bytes.Length);value = BitConverter.ToInt16(bytes, 0);}else if (property.PropertyType == typeof(float)){bytes = new byte[sizeof(float)];stream.Read(bytes, 0, bytes.Length);value = BitConverter.ToSingle(bytes, 0);}else if (property.PropertyType == typeof(double)){bytes = new byte[sizeof(double)];stream.Read(bytes, 0, bytes.Length);value = BitConverter.ToDouble(bytes, 0);}property.SetValue(price, value);index += bytes.Length;}result.Add(price);}return result;}
}
Name | Serialize(ms) | Deserialize(ms) | Bytes |
---|---|---|---|
ReflectionSerializer | 413 | 431 | 103,246 |
好像好了一些,但性能大幅下降。我好像记得有人说过.NET会将反射缓存让我不必担心反射带来的性能问题,看来我的理解有出入。索性自己缓存些反射结果:
private readonly IEnumerable<PropertyInfo> _properties;public ExtendReflectionSerializer()
{_properties = typeof(StockPriceSlim).GetProperties().Where(p => p.GetCustomAttribute(typeof(DataMemberAttribute)) != null).ToList();
}
Name | Serialize(ms) | Deserialize(ms) | Bytes |
---|---|---|---|
ExtendReflectionSerializer | 11 | 11 | 103,246 |
这样改进后性能还可以接受。
6. 最后试试压缩
最后试试在序列化的基础上再随便压缩一下:
public byte[] SerializeWithZip(List<StockPriceSlim> instance)
{var bytes = SerializeSlim(instance);using (var memoryStream = new MemoryStream()){using (var deflateStream = new DeflateStream(memoryStream, CompressionLevel.Fastest)){deflateStream.Write(bytes, 0, bytes.Length);}return memoryStream.ToArray();}
}public List<StockPriceSlim> DeserializeWithZip(byte[] source)
{using (var originalFileStream = new MemoryStream(source)){using (var memoryStream = new MemoryStream()){using (var decompressionStream = new DeflateStream(originalFileStream, CompressionMode.Decompress)){decompressionStream.CopyTo(memoryStream);}var bytes = memoryStream.ToArray();return DeserializeSlim(bytes);}}
}
结果看来不错:
Name | Serialize(ms) | Deserialize(ms) | Bytes | Serialize With Zip(ms) | Deserialize With Zip(ms) | Bytes With Zip |
---|---|---|---|---|---|---|
BinarySerializer | 11 | 12 | 141,930 | 22 | 12 | 72,954 |
XmlSerializer | 42 | 24 | 977,248 | 24 | 28 | 108,839 |
SoapSerializer | 48 | 89 | 2,586,720 | 61 | 87 | 140,391 |
JsonSerializer | 17 | 33 | 411,942 | 24 | 35 | 90,125 |
ProtobufSerializer | 7 | 3 | 130,416 | 7 | 6 | 65,644 |
CustomSerializer | 5 | 1 | 103,246 | 9 | 3 | 57,697 |
ReflectionSerializer | 413 | 431 | 103,246 | 401 | 376 | 59,285 |
ExtendReflectionSerializer | 11 | 11 | 103,246 | 13 | 14 | 59,285 |
7. 结语
满足了好奇心,顺便复习了一下各种序列化的方式。
因为原来的需求就很单一,没有测试各种数据量下的对比。
虽然Protobuf十分优秀,但在本地存储序列化文件时为了可读性我通常都会选择XML或JSON。
8. 参考
二进制序列化
XML 和 SOAP 序列化
Json.NET
Protocol Buffers - Google's data interchange format
9. 源码
StockDataSample
转载于:https://www.cnblogs.com/lonelyxmas/p/9914947.html
[.NET]使用十年股价对比各种序列化技术相关推荐
- 加密芯片十大品牌对比
加密芯片十大品牌对比 各大品牌加密芯片厂商都为各自的加密芯片定了型号,用户在进行加密芯片的选型时,如果没有明确的参考依据,很难效率而准确的选取到合适的加密芯片.作者结合自身经验,为大家提供一些简单实用 ...
- 微信小程序与传统APP十大优劣对比
随着微信公众平台的开放,微信端小程序涌现市场,带来很很多便利和简单的原生操作,询:微信端小程序是否会替代传统的APP应用?两者的优劣如何?我们一起来看看传统APP与微信端小程序十大优劣对比 ...
- Lora和Zigbee无线通讯技术的对比(哪种技术更适合物联网连接)
Lora和Zigbee无线通讯技术的对比(哪种技术更适合物联网连接) ZigBee是基于IEEE802.15.4标准的低功耗局域网协议,LoRa是LPWAN通信技术中的一种,那么lora技术和ZigB ...
- Gartner预测2019年十大「数据和分析技术」趋势:增强型分析成为重要卖点
来源:机器之能 摘要:处于数据和分析位置的领导人必须审视这些趋势对业务带来的潜在影响,并相应调整业务模式和运营,否则就有可能失去竞争优势.增强型数据分析,增强型数据管理,持续型智能,可解释的 AI,数 ...
- Java序列化技术与Protobuff
前言: Java序列化是Java技术体系当中的一个重要议题,序列化的意义在于信息的交换和存储,通常会和io.持久化.rmi技术有关(eg:一些orm框架会要求持久化的对象类型实现Serializabl ...
- [系统安全] 四十四.APT系列(9)Metasploit技术之基础用法万字详解及防御机理
您可能之前看到过我写的类似文章,为什么还要重复撰写呢?只是想更好地帮助初学者了解病毒逆向分析和系统安全,更加成体系且不破坏之前的系列.因此,我重新开设了这个专栏,准备系统整理和深入学习系统安全.逆向分 ...
- 序列化技术的选型-选型建议
1. 对性能要求不高的场景,可以采用基于XML的SOAP协议 2. 对性能和间接性有比较高要求的场景,那么Hessian.Protobuf.Thrift.Avro都可以. 3. 基于前后端分离,或者独 ...
- js 序列化内置对象_内置序列化技术
js 序列化内置对象 本文是我们名为" 高级Java "的学院课程的一部分. 本课程旨在帮助您最有效地使用Java. 它讨论了高级主题,包括对象创建,并发,序列化,反射等. 它将指 ...
- Java序列化技术即将被废除!!!
我们的对象并不只是存在内存中,还需要传输网络,或者保存起来下次再加载出来用,所以需要Java序列化技术.Java序列化技术正是将对象转变成一串由二进制字节组成的数组,可以通过将二进制数据保存到磁盘或者 ...
最新文章
- 软件开发经验总结(一)细节决定软件的成败
- 创新实训团队记录:为BR-MTC问题设计一个近似算法
- Flutter 制作漂亮的登录表单
- MySQL使用覆盖索引来优化limit语句
- stream distinct去重_再来看看Java的新特性——Stream流
- boost::gregorian模块实现自年初以来的天数的测试程序
- mongodb存list_查询 MongoDB 子文档的 List 字段
- Linux 桌面玩家指南:09. X Window 的奥秘
- 2-1:C++快速入门之命名空间
- OJ1043: 最大值(C语言)
- Android 主人VS宠物 游戏
- 推荐第三方SQL查询工具
- Introduction to Computer Networking学习笔记(十五):End to End Delay 端对端延迟
- 2020年ACM算法竞赛夏季短学期 任务安排
- c#怎样将object转换过程int型
- linux解除硬盘加密,linux下硬盘加密
- 在AI眼前“隐身”,用特制贴欺骗AI计算机视觉
- 【1945. 字符串转化后的各位数字之和】
- 引入时间轴:动态图模型的共性与特征
- 组件-Element—Badge(标记)
热门文章
- python编程狮app_Python编程狮官方app下载_Python编程狮安卓app下载 v1.0.8 - 创意手游...
- python3异步task_并发,异步编程_Python中的asyncio模块中的Future和Task的区别?,并发,异步编程,python,asyncio - phpStudy...
- 腐蚀rust图纸怎么找_怎么解决变压器油滤油机的温差效应?在这里可以得到解决...
- 请领导批阅文件怎么说_有请考过的说物业经理资格证怎么考?
- go web框架_干货分享:六个知名的Go语言web框架
- asp.net 抓取html内容,c# – 如何从ASP.NET获取网页的HTML内容
- influxdb tsm文件_Influxdb中TSM文件结构解析之读写TSM
- RPC框架的实现原理是什么?-开课吧
- 开课吧:AI改变就业市场的方式有哪些?
- 蚂蚁、字节、拼多多,你的简历能通过几家?