Разбор файла JSON с помощью.NET core 3.0/System.text.Json

Question

Я пытаюсь прочитать и проанализировать большой файл JSON, который не помещается в памяти, с помощью нового читателя JSON System.Text.Json в.NET Core 3.0.

Пример кода от Microsoft занимает ReadOnlySpan<byte> как вход

    public static void Utf8JsonReaderLoop(ReadOnlySpan<byte> dataUtf8)
    {
        var json = new Utf8JsonReader(dataUtf8, isFinalBlock: true, state: default);

        while (json.Read())
        {
            JsonTokenType tokenType = json.TokenType;
            ReadOnlySpan<byte> valueSpan = json.ValueSpan;
            switch (tokenType)
            {
                case JsonTokenType.StartObject:
                case JsonTokenType.EndObject:
                    break;
                case JsonTokenType.StartArray:
                case JsonTokenType.EndArray:
                    break;
                case JsonTokenType.PropertyName:
                    break;
                case JsonTokenType.String:
                    string valueString = json.GetString();
                    break;
                case JsonTokenType.Number:
                    if (!json.TryGetInt32(out int valueInteger))
                    {
                        throw new FormatException();
                    }
                    break;
                case JsonTokenType.True:
                case JsonTokenType.False:
                    bool valueBool = json.GetBoolean();
                    break;
                case JsonTokenType.Null:
                    break;
                default:
                    throw new ArgumentException();
            }
        }

        dataUtf8 = dataUtf8.Slice((int)json.BytesConsumed);
        JsonReaderState state = json.CurrentState;
    }

Я пытаюсь выяснить, как на самом деле использовать этот код с FileStream, получив FileStream в ReadOnlySpan<byte>,

Я попытался прочитать файл, используя следующий код и ReadAndProcessLargeFile("latest-all.json");

    const int megabyte = 1024 * 1024;
    public static void ReadAndProcessLargeFile(string theFilename, long whereToStartReading = 0)
    {
        FileStream fileStram = new FileStream(theFilename, FileMode.Open, FileAccess.Read);
        using (fileStram)
        {
            byte[] buffer = new byte[megabyte];
            fileStram.Seek(whereToStartReading, SeekOrigin.Begin);
            int bytesRead = fileStram.Read(buffer, 0, megabyte);
            while (bytesRead > 0)
            {
                ProcessChunk(buffer, bytesRead);
                bytesRead = fileStram.Read(buffer, 0, megabyte);
            }

        }
    }

    private static void ProcessChunk(byte[] buffer, int bytesRead)
    {
        var span = new ReadOnlySpan<byte>(buffer);
        Utf8JsonReaderLoop(span);
    }

Вылетает с сообщением об ошибке

System.Text.Json.JsonReaderException: 'Expected end of string, but instead reached end of data. LineNumber: 8 | BytePositionInLine: 123335.'

В качестве ссылки, вот мой рабочий код, который использует Newtonsoft.Json

        dynamic o;
        var serializer = new Newtonsoft.Json.JsonSerializer();
        using (FileStream s = File.Open("latest-all.json", FileMode.Open))
        using (StreamReader sr = new StreamReader(s))
        using (JsonReader reader = new JsonTextReader(sr))
        {
            while (reader.Read())
            {
                if (reader.TokenType == JsonToken.StartObject)
                {
                    o = serializer.Deserialize(reader);
                 }
            }
        }

Answer 1

Я создал легкую оболочку вокруг Utf8JsonReader именно для этой цели:

public ref struct Utf8JsonStreamReader
{
    private readonly Stream _stream;
    private IMemoryOwner<byte> _buffer;

    private Utf8JsonReader _jsonReader;
    private int _dataSize;

    public Utf8JsonStreamReader(Stream stream)
    {
        _stream = stream;
        _buffer = MemoryPool<byte>.Shared.Rent(32 * 1024);

        _jsonReader = default;
        _dataSize = -1;
    }

    public void Dispose()
    {
        _buffer.Dispose();
    }

    public bool Read()
    {
        // read could be unsuccessful due to insufficient buffer size, retrying in loop with increasing buffer sizes
        while (!_jsonReader.Read())
        {
            if (_dataSize == 0)
                return false;

            MoveNext();
        }

        return true;
    }

    private void MoveNext()
    {
        int leftOver = 0;

        if (_dataSize != -1)
        {
            leftOver = _dataSize - (int)_jsonReader.CurrentState.BytesConsumed;

            if (leftOver == _buffer.Memory.Length)
            {
                // current JSON token is to large to fit in buffer, try growing buffer
                var newBuffer = MemoryPool<byte>.Shared.Rent(2 * _buffer.Memory.Length);

                _buffer.Memory.CopyTo(newBuffer.Memory);
                _buffer.Dispose();

                _buffer = newBuffer;
            }

            if (leftOver != 0)
            {
                // we haven't read to the end of previous buffer, carry forward
                _buffer.Memory.Slice(_dataSize - leftOver, leftOver).CopyTo(_buffer.Memory);
            }
        }

        _dataSize = leftOver + _stream.Read(_buffer.Memory[leftOver..].Span);
        _jsonReader = new Utf8JsonReader(_buffer.Memory[0.._dataSize].Span, _dataSize == 0, _jsonReader.CurrentState);
    }

    public JsonTokenType TokenType => _jsonReader.TokenType;
    public SequencePosition Position => _jsonReader.Position;
    public bool HasValueSequence => _jsonReader.HasValueSequence;
    public int CurrentDepth => _jsonReader.CurrentDepth;
    public long BytesConsumed => _jsonReader.BytesConsumed;
    public ReadOnlySequence<byte> ValueSequence => _jsonReader.ValueSequence;
    public ReadOnlySpan<byte> ValueSpan => _jsonReader.ValueSpan;
    public bool GetBoolean() => _jsonReader.GetBoolean();
    public decimal GetDecimal() => _jsonReader.GetDecimal();
    public double GetDouble() => _jsonReader.GetDouble();
    public int GetInt32() => _jsonReader.GetInt32();
    public long GetInt64() => _jsonReader.GetInt64();
    public float GetSingle() => _jsonReader.GetSingle();
    public string GetString() => _jsonReader.GetString();
    public uint GetUInt32() => _jsonReader.GetUInt32();
    public ulong GetUInt64() => _jsonReader.GetUInt64();
    public bool TryGetDecimal(out decimal value) => _jsonReader.TryGetDecimal(out value);
    public bool TryGetDouble(out double value) => _jsonReader.TryGetDouble(out value);
    public bool TryGetInt32(out int value) => _jsonReader.TryGetInt32(out value);
    public bool TryGetInt64(out long value) => _jsonReader.TryGetInt64(out value);
    public bool TryGetSingle(out float value) => _jsonReader.TryGetSingle(out value);
    public bool TryGetUInt32(out uint value) => _jsonReader.TryGetUInt32(out value);
    public bool TryGetUInt64(out ulong value) => _jsonReader.TryGetUInt64(out value);
}

Используйте его точно так же, как вы бы использовали Utf8JsonReader. Вам понадобится C# 8 (для поддержки ref struct dispose), и не забудьте удалить его в конце.

Answer 2

В .NET 6 или более поздней версии мы можем использовать метод DeserializeAsyncEnumerable для потокового чтения большого файла JSON, содержащего массив элементов. Я использовал это для обработки файла JSON размером 5 ГБ с>100 000 элементов.

      using var file = File.OpenRead(path);
var items = JsonSerializer.DeserializeAsyncEnumerable<JsonElement>(file);
await foreach (var item in items)
{
    // Process JSON object
}

Answer 3

Если вы используете async, есть метод, который принимает поток (плюс общую версию)

      DeserializeAsync(Stream utf8Json, Type returnType, JsonSerializerOptions options = null, CancellationToken cancellationToken = default);