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的话, 那么将生成这样的代码
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()==',')
    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的使用及功能描述
KoobooJson当前支持6个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)
void Kooboo.Json.JsonSerializer.ToJson<T>(T value, StreamWriter streamWriter, JsonSerializerOption option = null)
T Kooboo.Json.JsonSerializer.ToObject<T>(StreamReader streamReader, JsonDeserializeOption option = null)
object Kooboo.Json.JsonSerializer.ToObject(StreamReader streamReader, 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\":{}}
忽略Null值
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}
Dictionary的Key格式
在Json规范中,键值对的键必须是字符串类型,在KoobooJson中,对Key的类型允许所有基元类型(Boolean, Byte, SByte, Int16, UInt16, Int32, UInt32, Int64, UInt64, IntPtr, UIntPtr, Char, Double, and Single)和String,以及Datetime,GUID,Enum,共18种支持的类型
JObject和JArray
反序列化时,对Object的类型解析,最终将会产生5种结果: Bool,数值(long,ulong,double),String,JArray,JObject
其中,JArray代表着数组,它拥有List的所有特性.
JObject代表着键值对,它拥有Dictionary<string,object>的所有特性.

忽略默认值元素
[IgnoreDefaultValue]
class User
    public int? Num { get; set; }
    public int Age { get; set; }
    public string Name { get; set; }
var json = JsonSerializer.ToJson(new User());
json=> {}
如果你想在序列化时,忽略默认值的元素,那么可以对这个类型标记[IgnoreDefaultValue]特性,也可以标记在属性或者字段上
忽略序列化元素
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";
             return ConvertToBase64((byte[])value);
    public override object ReadValueFormat(string value,Type type, JsonDeserializeHandler handler, out bool isValueFormat)
        isValueFormat=true;
        if(value=="null")
            return null;
            return Base64Convert(value);
值格式化特性也可以标记在结构体或类上, 而另一点是对于值格式化器, 也可以以全局的方式来进行配置：
以序列化为例, 可通过 JsonSerializerOption中的GlobalValueFormat委托来进行配置
JsonSerializerOption.GlobalValueFormat=(value,type,handler,isValueFormat)=>
	 if(type==typeof(byte[]))
		 isValueFormat=true;
		 if(value==null)
			      return "null";
			      return ConvertToBase64((byte[])value);
		isValueFormat=false;
		return null;
值得注意的是,对于byte[]类型的base64解析行为, KoobooJson已经内嵌在配置项中, 只要设置JsonSerializerOption.IsByteArrayFormatBase64=true即可
全局Key格式化
对于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;