如何使用Json.net作为流将JSON转换为BSON

Question

我想将JSON文件转换为BSON文件。 使用JsonTextReader和BsonDataWriter的方法JsonTextReader BsonDataWriter ？

这是代码：

using ( StreamReader textReader = File.OpenText(@"k:\\BrokeredMessage_Alarmhub-Infra-Prd-Sbn_08-06-2019 11-13-34.json" ) )
using ( JsonTextReader jsonTextReader = new JsonTextReader( textReader ))
using ( FileStream oFileStream = new FileStream( @"k:\\output.bson", FileMode.CreateNew ) )
using ( BsonDataWriter datawriter = new BsonDataWriter (oFileStream) )
{
   ...
}

我不想反序列化JSON文件的全部内容，因为我想读取JSON文件并以最小的内存负载写入BSON文件。 使用流是否可以？

Answer 1

BsonDataWriter继承自JsonWriter因此您可以使用JsonWriter.WriteToken(JsonReader)从JSON流复制到BSON流（反之亦然，使用BsonDataReader ）：

public static class JsonExtensions
{
    public static void CopyToBson(string inputPath, string outputPath, FileMode fileMode = FileMode.CreateNew)
    {
        using ( var textReader = File.OpenText(inputPath) )
        using ( var jsonReader = new JsonTextReader( textReader ))
        using ( var oFileStream = new FileStream( outputPath, fileMode ) )
        using ( var dataWriter = new BsonDataWriter(oFileStream) )
        {
            dataWriter.WriteToken(jsonReader);
        }
    }
}

笔记：

1. 您可能需要添加错误处理，以在发生错误时删除部分创建的输出文件。

2. BSON文档的根令牌必须是一个对象或数组，因此仅由原始值组成的JSON输入将导致此方法引发错误。

3. 根据BSON规范 ，数组是一个普通的BSON文档，其密钥的整数值从0开始，并依次连续。 因此，如果将包含数组的JSON转换为BSON，然后将BSON加载到JToken （或dynamic ）中，则将获得带有数字键而不是数组的对象。

4. BSON支持已移至Json.NET 10.0.1其自己的软件包Newtonsoft.Json.Bson中。 在早期版本中，请使用BsonWriter 。

5. 即使您正在使用流，如对Json.Net中Streams和BsonWriter的OutOfMemory Exception的 回答中所解释的，您可能也无法获得所需的内存性能：

   根据BSON规范 ，每个对象或数组-在标准中称为文档 -必须在开始时包含构成文档的字节总数的计数...

   Newtonsoft的BsonDataWriter和基础BsonBinaryWriter通过将所有要写入树中的令牌缓存起来，然后在确定完根令牌的内容之后，在写出树之前递归计算大小来实现此目的。

演示小提琴＃1 在这里 。

---

如果BsonDataWriter创建的令牌高速缓存超出了系统的内存，则您将需要手动实现从JsonReader BSON流的算法，并在完成输出后返回输出流以写出最终对象的大小。

例如，假设您的JSON根容器是JSON对象数组。 然后，以下方法将对数组进行增量序列化，然后在流中进行搜索以写入总大小：

public static partial class BsonExtensions
{
    public static void CopyJsonToBson(string inputPath, string outputPath, FileMode fileMode)
    {
        using ( var textReader = File.OpenText(inputPath) )
        using ( var jsonReader = new JsonTextReader( textReader ))
        using ( var oFileStream = new FileStream( outputPath, fileMode ) )
        {
            CopyJsonToBson(jsonReader, oFileStream);
        }
    }

    public static void CopyJsonToBson(JsonReader jsonReader, Stream stream)
    {
        var rootTokenType = jsonReader.ReadToContentAndAssert().TokenType;
        if (!stream.CanSeek || rootTokenType != JsonToken.StartArray)
        {
            using ( var dataWriter = new BsonDataWriter(stream) { CloseOutput = false } )
            {
                dataWriter.WriteToken(jsonReader, stream.CanSeek);
            }
        }
        else
        {
            stream.Flush(); // Just in case.

            var initialPosition = stream.Position;
            var buffer = new byte[256];

            WriteInt(stream, 0, buffer); // CALCULATED SIZE TO BE CALCULATED LATER.

            ulong index = 0;

            while (jsonReader.ReadToContentAndAssert().TokenType != JsonToken.EndArray)
            {
                var bsonType = GetBsonType(jsonReader.TokenType, jsonReader.ValueType);
                stream.WriteByte(unchecked((byte)bsonType));
                WriteString(stream, index.ToString(NumberFormatInfo.InvariantInfo), buffer);
                using (var dataWriter = new BsonDataWriter(stream) { CloseOutput = false })
                {
                    dataWriter.WriteToken(jsonReader);
                }
                index++;
            }

            stream.WriteByte((byte)0);
            stream.Flush();

            var finalPosition = stream.Position;
            stream.Position = initialPosition;

            var size = checked((int)(finalPosition - initialPosition));
            WriteInt(stream, size, buffer); // CALCULATED SIZE TO BE CALCULATED LATER.

            stream.Position = finalPosition;
        }
    }

    private static readonly Encoding Encoding = new UTF8Encoding(false);

    private static void WriteString(Stream stream, string s, byte[] buffer)
    {
        if (s != null)
        {
            if (s.Length < buffer.Length / Encoding.GetMaxByteCount(1))
            {
                var byteCount = Encoding.GetBytes(s, 0, s.Length, buffer, 0);
                stream.Write(buffer, 0, byteCount);
            }
            else
            {
                byte[] bytes = Encoding.GetBytes(s);
                stream.Write(bytes, 0, bytes.Length);
            }
        }

        stream.WriteByte((byte)0);
    }       

    private static void WriteInt(Stream stream, int value, byte[] buffer)
    {
        unchecked
        {
            buffer[0] = (byte) value;
            buffer[1] = (byte) (value >> 8);
            buffer[2] = (byte) (value >> 16);
            buffer[3] = (byte) (value >> 24);
        }
        stream.Write(buffer, 0, 4);
    }

    private static BsonType GetBsonType(JsonToken jsonType, Type valueType)
    {
        switch (jsonType)
        {
            case JsonToken.StartArray:
                return BsonType.Array;

            case JsonToken.StartObject:
                return BsonType.Object;

            case JsonToken.Null:
                return BsonType.Null;

            // Add primitives as required.

            default:
                throw new JsonWriterException(string.Format("BsonType for {0} not implemented.", jsonType));
        }
    }

    //Copied from: https://github.com/JamesNK/Newtonsoft.Json.Bson/blob/master/Src/Newtonsoft.Json.Bson/BsonType.cs
    //Original source: http://bsonspec.org/spec.html
    enum BsonType : sbyte
    {
        Number = 1,
        String = 2,
        Object = 3,
        Array = 4,
        Binary = 5,
        Undefined = 6,
        Oid = 7,
        Boolean = 8,
        Date = 9,
        Null = 10,
        Regex = 11,
        Reference = 12,
        Code = 13,
        Symbol = 14,
        CodeWScope = 15,
        Integer = 16,
        TimeStamp = 17,
        Long = 18,
        MinKey = -1,
        MaxKey = 127
    }       
}

public static partial class JsonExtensions
{
    public static JsonReader ReadToContentAndAssert(this JsonReader reader)
    {
        return reader.ReadAndAssert().MoveToContentAndAssert();
    }

    public static JsonReader MoveToContentAndAssert(this JsonReader reader)
    {
        if (reader == null)
            throw new ArgumentNullException();
        if (reader.TokenType == JsonToken.None)       // Skip past beginning of stream.
            reader.ReadAndAssert();
        while (reader.TokenType == JsonToken.Comment) // Skip past comments.
            reader.ReadAndAssert();
        return reader;
    }

    public static JsonReader ReadAndAssert(this JsonReader reader)
    {
        if (reader == null)
            throw new ArgumentNullException();
        if (!reader.Read())
            throw new JsonReaderException("Unexpected end of JSON stream.");
        return reader;
    }
}

然后按以下方式使用它：

var inputPath = @"k:\\BrokeredMessage_Alarmhub-Infra-Prd-Sbn_08-06-2019 11-13-34.json";
var outputPath = @"k:\\output.bson";

BsonExtensions.CopyJsonToBson(inputPath, outputPath, FileMode.Create);

笔记：

1. 我专门针对数组的情况实现了流式+寻找，因为这似乎是处理大型JSON文件的最常见情况。

2. 话虽如此，它可以通过遵循标准中的document规范进行扩展以流式传输JSON对象，并且可以通过增强BsonExtensions.GetBsonType()并对其进行适当格式化来扩展以处理原始值。

3. 这样，例程就可以递归地调用自身，当根对象包含一个非常大的数组作为成员时，这可能很有用。 （不过，到目前为止，您基本上已经编写了自己的BsonDataWriter版本。）

   但是，这样做可能会在输出流中导致大量搜索，这可能会极大地影响性能。

演示小提琴＃2 在这里 。