< Summary

Information
Class: System.Text.Json.Serialization.Converters.SlimObjectConverter
Assembly: System.Text.Json
File(s): C:\h\w\B31A098C\w\BB5A0A33\e\runtime-utils\Runner\runtime\src\libraries\System.Text.Json\src\System\Text\Json\Serialization\Converters\Object\ObjectConverter.cs
Line coverage
0%
Covered lines: 0
Uncovered lines: 4
Coverable lines: 4
Total lines: 149
Line coverage: 0%
Branch coverage
N/A
Covered branches: 0
Total branches: 0
Branch coverage: N/A
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Cyclomatic complexity NPath complexity Sequence coverage
.ctor(...)100%110%
Read(...)100%110%

File(s)

C:\h\w\B31A098C\w\BB5A0A33\e\runtime-utils\Runner\runtime\src\libraries\System.Text.Json\src\System\Text\Json\Serialization\Converters\Object\ObjectConverter.cs

#LineLine coverage
 1// Licensed to the .NET Foundation under one or more agreements.
 2// The .NET Foundation licenses this file to you under the MIT license.
 3
 4using System.Diagnostics;
 5using System.Text.Json.Nodes;
 6using System.Text.Json.Schema;
 7using System.Text.Json.Serialization.Metadata;
 8
 9namespace System.Text.Json.Serialization.Converters
 10{
 11    internal abstract class ObjectConverter : JsonConverter<object?>
 12    {
 13        private protected override ConverterStrategy GetDefaultConverterStrategy() => ConverterStrategy.Object;
 14
 15        public ObjectConverter()
 16        {
 17            CanBePolymorphic = true;
 18        }
 19
 20        public sealed override object ReadAsPropertyName(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOp
 21        {
 22            ThrowHelper.ThrowNotSupportedException_DictionaryKeyTypeNotSupported(Type, this);
 23            return null!;
 24        }
 25
 26        internal sealed override object ReadAsPropertyNameCore(ref Utf8JsonReader reader, Type typeToConvert, JsonSerial
 27        {
 28            ThrowHelper.ThrowNotSupportedException_DictionaryKeyTypeNotSupported(Type, this);
 29            return null!;
 30        }
 31
 32        public sealed override void Write(Utf8JsonWriter writer, object? value, JsonSerializerOptions options)
 33        {
 34            if (value is null)
 35            {
 36                writer.WriteNullValue();
 37                return;
 38            }
 39
 40            writer.WriteStartObject();
 41            writer.WriteEndObject();
 42        }
 43
 44        public sealed override void WriteAsPropertyName(Utf8JsonWriter writer, object value, JsonSerializerOptions optio
 45        {
 46            WriteAsPropertyNameCore(writer, value, options, isWritingExtensionDataProperty: false);
 47        }
 48
 49        internal sealed override void WriteAsPropertyNameCore(Utf8JsonWriter writer, object value, JsonSerializerOptions
 50        {
 51            ArgumentNullException.ThrowIfNull(value);
 52
 53            Type runtimeType = value.GetType();
 54            if (runtimeType == Type)
 55            {
 56                ThrowHelper.ThrowNotSupportedException_DictionaryKeyTypeNotSupported(runtimeType, this);
 57            }
 58
 59            JsonConverter runtimeConverter = options.GetConverterInternal(runtimeType);
 60            runtimeConverter.WriteAsPropertyNameCoreAsObject(writer, value, options, isWritingExtensionDataProperty);
 61        }
 62    }
 63
 64    /// <summary>
 65    /// Defines an object converter that only supports (polymorphic) serialization but not deserialization.
 66    /// This is done to avoid rooting dependencies to JsonNode/JsonElement necessary to drive object deserialization.
 67    /// Source generator users need to explicitly declare support for object so that the derived converter gets used.
 68    /// </summary>
 69    internal sealed class SlimObjectConverter : ObjectConverter
 70    {
 71        // Keep track of the originating resolver so that the converter surfaces
 72        // an accurate error message whenever deserialization is attempted.
 73        private readonly IJsonTypeInfoResolver _originatingResolver;
 74
 075        public SlimObjectConverter(IJsonTypeInfoResolver originatingResolver)
 076            => _originatingResolver = originatingResolver;
 77
 78        public override object? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
 079        {
 080            ThrowHelper.ThrowNotSupportedException_NoMetadataForType(typeToConvert, _originatingResolver);
 81            return null;
 82        }
 83    }
 84
 85    /// <summary>
 86    /// Defines an object converter that supports deserialization via JsonElement/JsonNode representations.
 87    /// Used as the default in reflection or if object is declared in the JsonSerializerContext type graph.
 88    /// </summary>
 89    internal sealed class DefaultObjectConverter : ObjectConverter
 90    {
 91        public DefaultObjectConverter()
 92        {
 93            // JsonElement/JsonNode parsing does not support async; force read ahead for now.
 94            RequiresReadAhead = true;
 95        }
 96
 97        public override object? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
 98        {
 99            if (options.UnknownTypeHandling == JsonUnknownTypeHandling.JsonElement)
 100            {
 101                return JsonElement.ParseValue(ref reader, options.AllowDuplicateProperties);
 102            }
 103
 104            Debug.Assert(options.UnknownTypeHandling == JsonUnknownTypeHandling.JsonNode);
 105            return JsonNodeConverter.Instance.Read(ref reader, typeToConvert, options);
 106        }
 107
 108        internal override bool OnTryRead(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options, s
 109        {
 110            object? referenceValue;
 111
 112            if (options.UnknownTypeHandling == JsonUnknownTypeHandling.JsonElement)
 113            {
 114                JsonElement element = JsonElement.ParseValue(ref reader, options.AllowDuplicateProperties);
 115
 116                // Edge case where we want to lookup for a reference when parsing into typeof(object)
 117                if (options.ReferenceHandlingStrategy == JsonKnownReferenceHandler.Preserve &&
 118                    JsonSerializer.TryHandleReferenceFromJsonElement(ref reader, ref state, element, out referenceValue)
 119                {
 120                    value = referenceValue;
 121                }
 122                else
 123                {
 124                    value = element;
 125                }
 126
 127                return true;
 128            }
 129
 130            Debug.Assert(options.UnknownTypeHandling == JsonUnknownTypeHandling.JsonNode);
 131
 132            JsonNode? node = JsonNodeConverter.Instance.Read(ref reader, typeToConvert, options);
 133
 134            if (options.ReferenceHandlingStrategy == JsonKnownReferenceHandler.Preserve &&
 135                JsonSerializer.TryHandleReferenceFromJsonNode(ref reader, ref state, node, out referenceValue))
 136            {
 137                value = referenceValue;
 138            }
 139            else
 140            {
 141                value = node;
 142            }
 143
 144            return true;
 145        }
 146
 147        internal override JsonSchema? GetSchema(JsonNumberHandling _) => JsonSchema.CreateTrueSchema();
 148    }
 149}
Generated by: ReportGenerator 5.5.1.0
2/25/2026 - 11:57:04 AM
GitHub | reportgenerator.io

Methods/Properties

.ctor(System.Text.Json.Serialization.Metadata.IJsonTypeInfoResolver)
Read(System.Text.Json.Utf8JsonReader&,System.Type,System.Text.Json.JsonSerializerOptions)