辉县市人民政府网,有益的昆虫,d盘
什么是kooboojson?
目前kooboojson只有130k, 并且没有任何额外依赖项, kooboojson当前支持框架版本.net4.5 .net core2+ .net standard 2
kooboojson 遵循json rfc8259规范, 是一款适用于c#的快速的json文本序列化器
它基于表达式树构建, 在运行时会动态的为每个类型生成高效的解析代码, 这过程包括: 利用静态泛型模板进行缓存, 避免字典查询开销, 避免装箱拆箱消耗, 缓冲池复用, 加速字节复制...
kooboojson生成代码的方式并没有采用emit, 而是采用expressiontree. expressiontree相比emit而言, 它不能像emit直接写出最优的il代码, 它依赖于下层的编译器, 在某些时候它会多生成一些不必要的il代码路径, 故而性能上有所逊色. 但相较于几乎没有类型检查的emit而言, expressiontree不会出现各种莫名其妙的错误, 它更加安全, 也更加容易扩展维护.
虽然expressiontree与emit相比在性能方面可能会有所差异, 但是kooboojson的表现却相当亮眼!
上图是使用benchmarkdotnet在net core2.1上做的json序列化和反序列化的性能测试,随机生成大量的测试数据,迭代100次后产生的结果,基准报告在这里
benchmarkdotnet=v0.11.4, os=windows 10.0.17763.316 (1809/october2018update/redstone5) intel core i7-8550u cpu 1.80ghz (kaby lake r), 1 cpu, 8 logical and 4 physical cores .net core sdk=2.1.505 [host] : .net core 2.1.9 (coreclr 4.6.27414.06, corefx 4.6.27415.01), 64bit ryujit job-xeqpps : .net core 2.1.9 (coreclr 4.6.27414.06, corefx 4.6.27415.01), 64bit ryujit
iterationcount=100 launchcount=1 warmupcount=1
在类型定义上, kooboojson并没有单独实现每个集合或键值对类型, 而是对这些fcl类型进行划分成不同的模板
a. kooboojson将序列化分为5种类型：
它包括 boolean, byte, sbyte, int16, uint16, int32, uint32, int64, uint64, intptr, uintptr, char, double, and single.
所有拥有键值对行为的类型
任何能够实现idictionary<>或能够实现idictionary且能够通过构造函数注入键值对的类型, 都将以键值对方式进行解析
所有拥有集合行为的类型
任何能够实现ienumable并且满足icolloction的add行为或拥有自己独特的集合行为且能够通过构造函数注入集合的类型, 都将以集合方式进行解析
特殊类型
如nullable<>, lazy<>, guid, datatable, datetime, type, task, thread, timespan...等等这些特定的类型实现
常规model的键值对类型
在kooboojson中, 如果当类型不满足上述4种时, 将会以键值对的形式来对其解析, kooboojson会对model中公开的所有元素进行序列化, 在这个环节, 几乎配置器中所有的配置都是有关model的. 诸如别名, 忽略特性, 指定构造函数, 忽略堆栈循环引用, 首字母大小写, 格式化器... 值得一提的是, 在对接口类型进行反序列化时, kooboojson默认会自动创建并返回一个实现于该接口的对象.
b. 在对类型的解析上, 其中浮点型,日期时间类型, guid的解析是参照了jil的代码, 在此表示感谢.
作为一款活跃的json库, kooboojson会不断支持更多的类型, 这其中, 因为对fcl中的键值对和集合的行为进行归纳, 所以对于这两种类型, kooboojson并不像其它框架一样去特定的为每种类型单独实现, 实际上, 第2和3所定义的规则可以容纳fcl中的大多数键值对或集合类型.
目前kooboojson所覆盖的类型包括 : hashtable, sortedlist, arraylist, idictionary, dictionary<,>, ilist,list<>, ienumerable<>, ienumerable, icollection, icollection<>, stack<>, queue<>, concurrentbag<>, concurrentqueue<>, concurrentstack<>, sorteddictionary<,>, concurrentdictionary<,>, sortedlist<,>, ireadonlydictionary<,>, readonlydictionary<,>, observablecollection<>, hashset<>, sortedset<>, linkedlist<>, readonlycollection<>, arraysegment<>, stack, queue, ireadonlylist<>, ireadonlycollection<>, readonlycollection<>, iset<>, bitarray, uri, namevaluecollection, stringdictionary, expandoobject, stringbuilder, nullable<>, lazy<>, guid, datatable, datetime, type, task, thread, timespan, enum, exception, array[], array[,,,,,]...
我要评论class usermodel
{
public object obj;
public string name;
public int age;
}
string json = jsonserializer.tojson(new usermodel());
在对类型第一次序列化时, kooboojson会为这个类型生成大致是这样的解析代码.
void writeusermodel(usermodel model,jsonserializerhandler handler)
{
...配置选项处理...格式化器处理...堆栈无限引用处理...
handler.sb.write("obj:")
writeobject(model.obj);//在序列化时将为object类型做二次真实类型查找
handler.sb.write("name:")
writestring(model.name);
handler.sb.write("age:")
writeint(model.age);
}
如果是list<usermodel>的话, 那么将生成这样的代码
handler.sb.write("[")
foreach(var user in users)
{
writeusermodel(user);
writecomma()
}
handler.sb.write("]")
在当前版本中, kooboojson序列化使用的容器为stringbuilder, 与直接ref char[]相比, 多了一些额外的调用. 将考虑在下个版本中构建一个轻便的char容器, 并会区分对象大小, 考虑栈数组和通过预扫描大小来减少对内存的开销,这将显著提升序列化速度.
在对类型进行第一次反序列化时, kooboojson会为这个类型生成大致是这样的解析代码.
usermodel model = jsonserializer.toobject<usermodel>("{\"obj\":3,\"name\":\"tom\",\"age\":18}");
void readusermodel(string json,jsondeserializehandler handler)
{
...null处理...
readobjleft()
空元素处理...构造函数处理...配置项处理...格式化器处理...
while(i-->0){
switch(gechar())
{
case 'o':
switch(getchar())
case 'b':
switch(getchar())
case 'j':
readquote();
readobject();
if(getchar()==',')
i++;
}
}
readobjright()
}
kooboojson生成反序列化代码, kooboojson会假设json格式完全正确, 没有预先读取json结构部分, 而是直接使用代码来描述结构, 所以kooboojson少了一次对json结构的扫描, 执行过程中如果json结构发生错误, 会直接抛出异常.
而对于key的匹配, kooboojson生成的是逐个char的自动机匹配代码, 目前kooboojson是以字典树为算法, 逐个char进行类型比较, 与一次比较多个char相比, 这种方式显然没有达到最小的查询路径, 不过在jit优化下, 两种方式实现经测试效率几乎一样.
在反序列化读取字符时, 因为是对类型动态生成编码, 提前知道每个类型中的元素的字节长度和其类型的值长度, 所以kooboojson出于更高的性能对反序列化采取了指针操作, 并加速字节读取.
case 3:
if (*(int*)pointer != *(int*)o) return false;
if (*(pointer + 2) != *(o + 2)) return false;
goto true;
case 4:
if (*(long*)pointer != *(long*)o) return false;
goto true;
case 5:
if (*(long*)pointer != *(long*)o) return false;
if (*(pointer + 4) != *(o + 4)) return false;
因为是指针操作, kooboojson在反序列化环节几乎不需要去维护一个char池来存放下一个需要读取的json结构片段.
kooboojson当前仅支持3个api调用
string kooboo.json.jsonserializer.tojson<t>(t value, jsonserializeroption option=null) t kooboo.json.jsonserializer.toobject<t>(string json, jsondeserializeoption option=null) object kooboo.json.jsonserializer.toobject(string json, type type, jsondeserializeoption option=null)
在json字符串的读取中kooboojson会自动忽略注释
string json = @"
/*注释*/
{//注释
/*注释*/""name"" /*注释*/: /*注释*/""cms"" /*注释*/,//注释
/*注释*/
""children"":[//注释
1/*注释*/,
2/*注释*/
]//注释
}//注释
/*此处*/
";
var obj = jsonserializer.toobject(json);
obj=>name：cms
obj=>children：array(2)
class a
{
public b b;
}
class b
{
public a a;
}
a.b=b;
b.a=a;
a指向b, b指向a, 在序列化时这种情况会发生无限循环.可通过kooboojson的序列化配置项中的属性来设定这种情况下所对应的结果
jsonserializeroption option = new jsonserializeroption
{
referenceloophandling = jsonreferencehandlingenum.null
};
string json = jsonserializer.tojson(a, option);
json => {\"b\":{\"a\":null}}
------
referenceloophandling = jsonreferencehandlingenum.empty
json => {\"b\":{\"a\":{}}}
-----
referenceloophandling = jsonreferencehandlingenum.remove
json => {\"b\":{}}
class a
{
public string a;
}
a.a=null;
jsonserializeroption option = new jsonserializeroption { isignorevaluenull = true };
var json = jsonserializer.tojson(a, option);
json => {}
class a
{
[jsonorder(3)]
public int a;
[jsonorder(2)]
public int b;
[jsonorder(1)]
public int c;
}
可通过[jsonorder(int ordernum)]来排序序列化的json元素位置. 如果是正常没有通过[jsonorder]排序元素,那么解析出来的json则是默认顺序：{"a":0,"b":0,"c":0} 上面样例通过[jsonorder]排序后是这样的：{"c":0,"b":0,"a":0}
class a
{
[ignorekey]
public int a;
public int b;
}
可通过[ignorekey]特性来标记序列化和反序列化要忽略的元素 json => {"b":0} 当然, 也可以通过配置来动态选择忽略对象
jsonserializeroption option = new jsonserializeroption { ignorekeys = new list<string>(){"b"} };
var json = jsonserializer.tojson(a, option);
json => {}
class a
{
[jsononlyinclude]
public int a;
public int b;
public int c;
}
json => {\"a\":0}
如果一个model里包含几十个元素, 而你仅想序列化其中一个, 那么就没必要对每一个元素进行[ignorekey]标记,只需要对想要序列化的元素标记[jsononlyinclude]即可
jsonserializeroption option = new jsonserializeroption { datetimeformat=datetimeformatenum.iso8601 };
json => 2012-01-02t03:04:05z
jsonserializeroption option = new jsonserializeroption { datetimeformat=datetimeformatenum.rfc1123 };
json => thu, 10 apr 2008 13:30:00 gmt
jsonserializeroption option = new jsonserializeroption { datetimeformat=datetimeformatenum.microsoft };
json => \/date(628318530718)\/
class a
{
public int name;
}
jsonserializeroption option = new jsonserializeroption { jsoncharacterread=jsoncharacterreadstateenum.initialupper };
json => {\"name\":0}
在对model序列化时可以指定key的首字母大小写,反序列化时也可以设置对字符串不区分大小写.首字母大小写属于内嵌支持, 在解析时并不会影响性能
class a
{
[alias("r01_name")]
public int name;
}
json => {\"r01_name\":0}
当元素被标记[alias]后,kooboojson无论序列化还是反序列化都会按照alias来进行解析
class a
{
public a(){}
[jsondeserializector(3,"ss")]
public a(int a,string b){}
}
在反序列化的时候, 我们不得不调用构造函数来以此创建对象. 在常规情况下, kooboojson会通过优先级自动搜索最合适的构造函数,其优先级顺序为: public noargs => private noargs => public args => private args, 这其中, 会对有参构造函数进行默认值构造.
然而你也可以显式通过[jsondeserializector(params object[] args)]特性来指定反序列化时的构造函数, 这样 当kooboojson创建a实例的时候就不是通过new a(); 而是new a(3,"ss");
class a
{
[base64valueformat]
public byte[] a;
}
当你需要来覆写由kooboojson进行元素解析的行为时, 我们可以继承一个 valueformatattribute 来覆写行为.
class base64valueformatattribute:valueformatattribute
{
public override string writevalueformat(object value,type type, jsonserializerhandler handler, out bool isvalueformat)
{
isvalueformat=true;
if(value==null)
return "null";
else
return converttobase64((byte[])value);
}
public override object readvalueformat(string value,type type, jsondeserializehandler handler, out bool isvalueformat)
{
isvalueformat=true;
if(value=="null")
return null;
else
return base64convert(value);
}
}
值格式化特性也可以标记在结构体或类上, 而另一点是对于值格式化器, 也可以以全局的方式来进行配置： 以序列化为例, 可通过 jsonserializeroption中的globalvalueformat委托来进行配置
jsonserializeroption.globalvalueformat=(value,type,handler,isvalueformat)=>
{
if(type==typeof(byte[]))
{
isvalueformat=true;
if(value==null)
return "null";
else
return converttobase64((byte[])value);
}
else
{
isvalueformat=false;
return null;
}
}
值得注意的是,对于byte[]类型的base64解析行为, kooboojson已经内嵌在配置项中, 只要设置jsonserializeroption.isbytearrayformatbase64=true即可
对于model中的key处理, kooboojson支持全局的key格式化器.
class r01_user
{
public string r01_name;
public int r01_age;
}
如果我们想把r01这个前缀给去掉, 只需要注册全局key格式化器的委托即可
jsonserializeroption.globalkeyformat=(key,parenttype,handler)=>
{
if(parenttype==typeof(r01_user))
{
return key.substring(4);
}
return key;
}
这样,出来的json是这样的：{"name":"","age":""
同样, 对于反序列化，我们也同样应该注册：
jsondeserializeoption.globalkeyformat=(key,parenttype)=>
{
if(parenttype==typeof(r01_user))
{
return "r01_"+key;
}
return key;
}
如对本文有疑问，请在下面进行留言讨论，广大热心网友会与你互动！！ 点击进行留言回复
Blazor server side 自家的一些开源的, 实用型项目的进度之 CEF客户端
.NET IoC模式依赖反转(DIP)、控制反转(Ioc)、依赖注入(DI)
vue+.netcore可支持业务代码扩展的开发框架 VOL.Vue 2.0版本发布
网友评论