分享一个快速的Json（反）序列化开源项目 Jil

我们不缺少JSON的序列化库，但我们缺少一个性能非常好的库，这对于网站来说非常重要。今天我发现了Jil。

他是开源的代码： https://github.com/kevin-montrose/Jil

在他主页上有详细的介绍其性能的表现，我这里就不转述了，他最重要的特点就是性能，Emit那当然不会少了，当想让他超越其他的库光一个Emit肯定不行，他还有很多其他的优化。

• 公共缓冲区

为介绍GC的压力，他使用了诸如builder.CommonCharBuffer这样的功能缓冲，builder.CommonStringBuffer也是这样的应用。

• 内联

很多的方法，都标记了[MethodImpl(MethodImplOptions.AggressiveInlining)]以便编译器尽可能的内联。

• 减少计算

比如将int转换为string，原先的代码是这样写的。

         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static void _CustomWriteInt(TextWriter writer, int number, char[] buffer)
         {
             // Gotta special case this, we can't negate it
             if (number == int.MinValue)
             {
                 writer.Write("-2147483648");
                 return;
             }

             var ptr = InlineSerializer<object>.CharBufferSize - ;

             var copy = number;
             if (copy < )
             {
                 copy = -copy;
             }

             do
             {
                 var ix = copy % ;
                 copy /= ;

                 buffer[ptr] = (char)('' + ix);
                 ptr--;
             } while (copy != );

             if (number < )
             {
                 buffer[ptr] = '-';
                 ptr--;
             }

             writer.Write(buffer, ptr + , InlineSerializer<object>.CharBufferSize -  - ptr);
         }

是不是觉得已经很好了，但是他们还不断进取，改成这样：

         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static void _CustomWriteInt(TextWriter writer, int number, char[] buffer)
         {
             var ptr = InlineSerializer<object>.CharBufferSize - ;

             uint copy;
             if (number >= )
                 copy = (uint)number;
             else
             {
                 writer.Write('-');
                 copy =  + (uint)~number;
             }

             do
             {
                 var ix = copy % ;
                 copy /= ;

                 var chars = DigitPairs[ix];
                 buffer[ptr--] = chars.Second;
                 buffer[ptr--] = chars.First;
             } while (copy != );

             if (buffer[ptr + ] == '')
                 ++ptr;

             writer.Write(buffer, ptr + , InlineSerializer<object>.CharBufferSize -  - ptr);
         }

其中，那个DigitPairs是什么呢？

 struct TwoDigits
         {
             public readonly char First;
             public readonly char Second;

             public TwoDigits(char first, char second)
             {
                 First = first;
                 Second = second;
             }
         }

         private static readonly TwoDigits[] DigitPairs;

         static Methods()
         {
             DigitPairs = new TwoDigits[];
             for (var i=; i < ; ++i)
                 DigitPairs[i] = new TwoDigits((char)('' + (i / )), (char)+('' + (i % )));
         }

是不是想法很高呢？

• 减少判断

原先的方法是这样的

 static bool IsWhiteSpace(int c)
         {
             // per http://www.ietf.org/rfc/rfc4627.txt
             // insignificant whitespace in JSON is defined as
             //  \u0020  - space
             //  \u0009  - tab
             //  \u000A  - new line
             //  \u000D  - carriage return

             return
                 c == 0x20 ||
                 c == 0x09 ||
                 c == 0x0A ||
                 c == 0x0D;
         }

可以这样改，哈哈，其实我想这么改，不知道对不对？因为我觉得大多数情况下不是空白，所以一直要判断4次才能返回，而我改成这样：

 static bool IsWhiteSpace(int c)
         {
             // per http://www.ietf.org/rfc/rfc4627.txt
             // insignificant whitespace in JSON is defined as
             //  \u0020  - space
             //  \u0009  - tab
             //  \u000A  - new line
             //  \u000D  - carriage return

             return
                 c < 0x21 && (
                 c == 0x20 ||
                 c == 0x09 ||
                 c == 0x0A ||
                 c == 0x0D);
         }