歡迎光臨
每天分享高質量文章

開源 , KoobooJson一款高性能且輕量的JSON框架

  在C#領域,有很多成熟的開源JSON框架,其中最著名且使用最多的是 Newtonsoft.Json ,然而因為版本迭代,其代碼要兼容從net2.0到現在的最新的net框架,並且要支持.net平臺下的其它語言,所以最新發佈版本的Newtonsoft.Json其dll大小接近700k,另一方面,因為其複雜的迭代歷史導致它的代碼為了維護向下擴展性和向上兼容性而捨棄一些性能。

  如果你不太在乎體積和性能的話,那麼 Newtonsoft.Json 無疑是一款很好的選擇。但是如果你在意性能的話,在github上仍然有一些出名的以速度為稱的c# JSON框架,其中最為人知的應該是 JIL , JIL有著出色的性能是因為它採用了大量的加速技術,但這也帶來了一些局限性,它不夠靈活,對object型別的解析必須得呼叫它的另一個API,並且因為出於性能考慮其採用的是Emit技術,不易維護,在我的測試中有很多型別它不支持。但是JIL的地位是顯而易見的,因為它的出現,github上有著很多相仿思路的以速度為稱的JSON框架,幾乎每個都稱自己是最快的,但實際上很少有超越JIL的,並且它們中的大部分沒有一個良好的文件,這導致我在做性能測試時,我想改個配置都得對原始碼全域性搜索花費一定時間。

  在說回程式集大小,JIL的最新發佈版本是500k,並且其依賴一個庫,加起來是800k大小。

  那麼,我講這些,大家應該知道我想要表達什麼!

  是的,考慮到前面種種,這些都不是在某種場景最理想化的那種JSON庫,所以我寫了一款以體積更小,速度更快,型別改寫更廣的開源C# JSON框架,它叫:KoobooJson

在我正式介紹KoobooJson之前,我要介紹一下什麼是Kooboo!

Kooboo是我們老闆用C#編寫的一個開源的非常神奇的網站開發工具,它是一個類CMS生成器,但其從資料庫,前端引擎,到各種網絡協議服務器都是用c#自主創造的,幾乎很少使用到第三方庫,它編譯後的發佈版本僅有幾M,而正是因為僅僅只有幾M,為了Json框架不要太影響主程式的大小,這才有了KoobooJson此次的誕生!

Kooboo是開源的:https://github.com/Kooboo/Kooboo

KoobooJson自然也是開源的:https://github.com/Kooboo/Json

在NuGet包中可以直接搜索 KoobooJson 下載使用即可

什麼是KoobooJson?

  KoobooJson是一款C#的JSON工具,其主要通過運算式技術構建,最低支持.NET4.5(可以支持.NET4.0,但考慮到一些因素,最終沒有支持,有需要支持的可以自行原始碼分支更改。另外,幾乎每個以性能號稱的JSON框架都最低支持.NET4.5),最低支持.NET Core 2.0,提交小巧,性能出色,型別改寫廣是KoobooJson的優點!

  • KoobooJson的優點
    • 小巧
    • 快速
    • 改寫型別廣
  • KoobooJson的實現  (後續我將出一篇新的文章詳細講解實現)
    • 序列化
    • 反序列化
  • 功能介紹
    • 忽略註釋
    • 忽略互取用所導致的堆棧迴圈
    • 忽略Null值
    • 排序特性
    • 忽略序列化元素
    • 序列化時僅包含該元素
    • 時間格式
    • 首字母大小寫
    • 別名特性
    • 反序列化時指定建構式
    • 值格式化特性
    • 全域性Key格式化
  • 其它

KoobooJson的優點

1. 小巧

目前KoobooJson只有130k, 並且沒有任何額外依賴項, KoobooJson當前支持框架版本.NET4.5 .NET Core2+ .NET Standard 2

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

3. 改寫型別廣

在型別定義上, 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[,,,,,]…

KoobooJson的實現

序列化

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("{\"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 value, JsonSerializerOption option=null)

T Kooboo.Json.JsonSerializer.ToObject(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\":{}}

忽略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}

忽略序列化元素

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即可

全域性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;
}

原文地址:https://www.cnblogs.com/1996V/p/10607916.html

赞(0)

分享創造快樂