Read< TValue >()

static TValue System.Text.Json.JsonSerializer.Read< TValue > ( ref Utf8JsonReader reader, JsonTypeInfo jsonTypeInfo )

inlinestaticprivate

Definition at line 1295 of file JsonSerializer.cs.

    {
        ReadStack state = default(ReadStack);
        state.Initialize(jsonTypeInfo);
        JsonReaderState currentState = reader.CurrentState;
        if (currentState.Options.CommentHandling == JsonCommentHandling.Allow)
        {
            throw new ArgumentException(System.SR.JsonSerializerDoesNotSupportComments, "reader");
        }
        Utf8JsonReader utf8JsonReader = reader;
        ReadOnlySpan<byte> readOnlySpan = default(ReadOnlySpan<byte>);
        ReadOnlySequence<byte> source = default(ReadOnlySequence<byte>);
        try
        {
            JsonTokenType tokenType = reader.TokenType;
            ReadOnlySpan<byte> bytes;
            if ((tokenType == JsonTokenType.None || tokenType == JsonTokenType.PropertyName) && !reader.Read())
            {
                bytes = default(ReadOnlySpan<byte>);
                ThrowHelper.ThrowJsonReaderException(ref reader, ExceptionResource.ExpectedOneCompleteToken, 0, bytes);
            }
            switch (reader.TokenType)
            {
            case JsonTokenType.StartObject:
            case JsonTokenType.StartArray:
            {
                long tokenStartIndex = reader.TokenStartIndex;
                if (!reader.TrySkip())
                {
                    bytes = default(ReadOnlySpan<byte>);
                    ThrowHelper.ThrowJsonReaderException(ref reader, ExceptionResource.NotEnoughData, 0, bytes);
                }
                long num = reader.BytesConsumed - tokenStartIndex;
                ReadOnlySequence<byte> originalSequence = reader.OriginalSequence;
                if (originalSequence.IsEmpty)
                {
                    bytes = reader.OriginalSpan;
                    readOnlySpan = checked(bytes.Slice((int)tokenStartIndex, (int)num));
                }
                else
                {
                    source = originalSequence.Slice(tokenStartIndex, num);
                }
                break;
            }
            case JsonTokenType.Number:
            case JsonTokenType.True:
            case JsonTokenType.False:
            case JsonTokenType.Null:
                if (reader.HasValueSequence)
                {
                    source = reader.ValueSequence;
                }
                else
                {
                    readOnlySpan = reader.ValueSpan;
                }
                break;
            case JsonTokenType.String:
            {
                ReadOnlySequence<byte> originalSequence2 = reader.OriginalSequence;
                if (originalSequence2.IsEmpty)
                {
                    bytes = reader.ValueSpan;
                    int length = bytes.Length + 2;
                    readOnlySpan = reader.OriginalSpan.Slice((int)reader.TokenStartIndex, length);
                    break;
                }
                long num2 = 2L;
                if (reader.HasValueSequence)
                {
                    num2 += reader.ValueSequence.Length;
                }
                else
                {
                    long num3 = num2;
                    bytes = reader.ValueSpan;
                    num2 = num3 + bytes.Length;
                }
                source = originalSequence2.Slice(reader.TokenStartIndex, num2);
                break;
            }
            default:
            {
                byte b;
                if (reader.HasValueSequence)
                {
                    bytes = reader.ValueSequence.First.Span;
                    b = bytes[0];
                }
                else
                {
                    bytes = reader.ValueSpan;
                    b = bytes[0];
                }
                byte nextByte = b;
                bytes = default(ReadOnlySpan<byte>);
                ThrowHelper.ThrowJsonReaderException(ref reader, ExceptionResource.ExpectedStartOfValueNotFound, nextByte, bytes);
                break;
            }
            }
        }
        catch (JsonReaderException ex)
        {
            reader = utf8JsonReader;
            ThrowHelper.ReThrowWithPath(ref state, ex);
        }
        int num4 = (readOnlySpan.IsEmpty ? checked((int)source.Length) : readOnlySpan.Length);
        byte[] array = ArrayPool<byte>.Shared.Rent(num4);
        Span<byte> span = array.AsSpan(0, num4);
        try
        {
            if (readOnlySpan.IsEmpty)
            {
                source.CopyTo(span);
            }
            else
            {
                readOnlySpan.CopyTo(span);
            }
            JsonReaderOptions options = currentState.Options;
            Utf8JsonReader reader2 = new Utf8JsonReader(span, options);
            JsonConverter converterBase = state.Current.JsonPropertyInfo.ConverterBase;
            return ReadCore<TValue>(converterBase, ref reader2, jsonTypeInfo.Options, ref state);
        }
        catch (JsonException)
        {
            reader = utf8JsonReader;
            throw;
        }
        finally
        {
            span.Clear();
            ArrayPool<byte>.Shared.Return(array);
        }
    }

References System.array, System.bytes, System.Collections.Generic.Dictionary< TKey, TValue >.Clear(), System.Collections.Generic.Dictionary< TKey, TValue >.CopyTo(), System.Text.Json.Dictionary, System.Text.Json.ReadStack.Initialize(), System.SR.JsonSerializerDoesNotSupportComments, System.L, System.length, System.options, System.Text.Json.JsonSerializer.ReadCore< TValue >(), System.Text.Json.ThrowHelper.ReThrowWithPath(), System.source, System.state, and System.Text.Json.ThrowHelper.ThrowJsonReaderException().

Referenced by System.Text.Json.JsonSerializer.Deserialize< TValue >(), and System.Text.Json.JsonSerializer.Deserialize< TValue >().