Improve serializer performance

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/FSharp/FSharpTypeConverterFactory.cs

@@ -8,7 +8,7 @@
 
 namespace System.Text.Json.Serialization.Converters
 {
-    internal class FSharpTypeConverterFactory : JsonConverterFactory
+    internal sealed class FSharpTypeConverterFactory : JsonConverterFactory
     {
         // Temporary solution to account for not implemented support for type-level attributes
         // TODO remove once addressed https://github.com/mono/linker/issues/1742#issuecomment-875036480

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Object/ObjectDefaultConverter.cs

@@ -16,6 +16,9 @@ internal class ObjectDefaultConverter<T> : JsonObjectConverter<T> where T : notn
     {
         internal override bool CanHaveIdMetadata => true;
 
+#if NET6_0_OR_GREATER
+        [MethodImpl(MethodImplOptions.AggressiveOptimization)]
+#endif
         internal override bool OnTryRead(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options, ref ReadStack state, [MaybeNullWhen(false)] out T value)
         {
             JsonTypeInfo jsonTypeInfo = state.Current.JsonTypeInfo;
@@ -246,6 +249,9 @@ internal override bool OnTryRead(ref Utf8JsonReader reader, Type typeToConvert,
             return true;
         }
 
+#if NET6_0_OR_GREATER
+        [MethodImpl(MethodImplOptions.AggressiveOptimization)]
+#endif
         internal sealed override bool OnTryWrite(
             Utf8JsonWriter writer,
             T value,
@@ -272,7 +278,7 @@ internal sealed override bool OnTryWrite(
                     onSerializing.OnSerializing();
                 }
 
-                List<KeyValuePair<string, JsonPropertyInfo?>> properties = state.Current.JsonTypeInfo.PropertyCache!.List;
+                List<KeyValuePair<string, JsonPropertyInfo?>> properties = jsonTypeInfo.PropertyCache!.List;
                 for (int i = 0; i < properties.Count; i++)
                 {
                     JsonPropertyInfo jsonPropertyInfo = properties[i].Value!;
@@ -291,7 +297,7 @@ internal sealed override bool OnTryWrite(
                 }
 
                 // Write extension data after the normal properties.
-                JsonPropertyInfo? dataExtensionProperty = state.Current.JsonTypeInfo.DataExtensionProperty;
+                JsonPropertyInfo? dataExtensionProperty = jsonTypeInfo.DataExtensionProperty;
                 if (dataExtensionProperty?.ShouldSerialize == true)
                 {
                     // Remember the current property for JsonPath support if an exception is thrown.
@@ -327,7 +333,7 @@ internal sealed override bool OnTryWrite(
                     state.Current.ProcessedStartToken = true;
                 }
 
-                List<KeyValuePair<string, JsonPropertyInfo?>>? propertyList = state.Current.JsonTypeInfo.PropertyCache!.List!;
+                List<KeyValuePair<string, JsonPropertyInfo?>>? propertyList = jsonTypeInfo.PropertyCache!.List!;
                 while (state.Current.EnumeratorIndex < propertyList.Count)
                 {
                     JsonPropertyInfo? jsonPropertyInfo = propertyList![state.Current.EnumeratorIndex].Value;
@@ -362,7 +368,7 @@ internal sealed override bool OnTryWrite(
                 // Write extension data after the normal properties.
                 if (state.Current.EnumeratorIndex == propertyList.Count)
                 {
-                    JsonPropertyInfo? dataExtensionProperty = state.Current.JsonTypeInfo.DataExtensionProperty;
+                    JsonPropertyInfo? dataExtensionProperty = jsonTypeInfo.DataExtensionProperty;
                     if (dataExtensionProperty?.ShouldSerialize == true)
                     {
                         // Remember the current property for JsonPath support if an exception is thrown.
@@ -407,7 +413,7 @@ internal sealed override bool OnTryWrite(
 
         // AggressiveInlining since this method is only called from two locations and is on a hot path.
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        protected void ReadPropertyValue(
+        protected static void ReadPropertyValue(
             object obj,
             ref ReadStack state,
             ref Utf8JsonReader reader,
@@ -438,7 +444,7 @@ protected void ReadPropertyValue(
             state.Current.EndProperty();
         }
 
-        protected bool ReadAheadPropertyValue(ref ReadStack state, ref Utf8JsonReader reader, JsonPropertyInfo jsonPropertyInfo)
+        protected static bool ReadAheadPropertyValue(ref ReadStack state, ref Utf8JsonReader reader, JsonPropertyInfo jsonPropertyInfo)
         {
             // Returning false below will cause the read-ahead functionality to finish the read.
             state.Current.PropertyState = StackFramePropertyState.ReadValue;

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Value/NullableConverter.cs

@@ -70,7 +70,5 @@ internal override void WriteNumberWithCustomHandling(Utf8JsonWriter writer, T? v
                 _converter.WriteNumberWithCustomHandling(writer, value.Value, handling);
             }
         }
-
-        internal override bool IsNull(in T? value) => !value.HasValue;
     }
 }

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonConverterOfT.cs

@@ -3,6 +3,7 @@
 
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
 using System.Text.Json.Serialization.Metadata;
 
 namespace System.Text.Json.Serialization
@@ -143,6 +144,9 @@ internal virtual bool OnTryRead(ref Utf8JsonReader reader, Type typeToConvert, J
         /// <remarks>Note that the value of <seealso cref="HandleNull"/> determines if the converter handles null JSON tokens.</remarks>
         public abstract T? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options);
 
+#if NET6_0_OR_GREATER
+        [MethodImpl(MethodImplOptions.AggressiveOptimization)]
+#endif
         internal bool TryRead(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options, ref ReadStack state, out T? value)
         {
             if (ConverterStrategy == ConverterStrategy.Value)
@@ -310,10 +314,13 @@ internal override sealed bool TryReadAsObject(ref Utf8JsonReader reader, JsonSer
         }
 
         /// <summary>
-        /// Overridden by the nullable converter to prevent boxing of values by the JIT.
+        /// Performance optimization. The 'in' modifier in TryWrite(in T Value) will cause boxing, so this helper method avoids that.
         /// </summary>
-        internal virtual bool IsNull(in T value) => value == null;
+        internal bool IsNull(T value) => value is null;
 
+#if NET6_0_OR_GREATER
+        [MethodImpl(MethodImplOptions.AggressiveOptimization)]
+#endif
         internal bool TryWrite(Utf8JsonWriter writer, in T value, JsonSerializerOptions options, ref WriteStack state)
         {
             if (writer.CurrentDepth >= options.EffectiveMaxDepth)
@@ -333,10 +340,14 @@ internal bool TryWrite(Utf8JsonWriter writer, in T value, JsonSerializerOptions
 
             if (
 #if NET5_0_OR_GREATER
-                !typeof(T).IsValueType && // treated as a constant by recent versions of the JIT.
+                // Short-circuit the check against "is not null"; treated as a constant by recent versions of the JIT.
+                !typeof(T).IsValueType &&
 #else
                 !IsValueType &&
 #endif
+                // Since we may have checked for a null value above we may have a redundant check here,
+                // but this seems to be better than trying to cache that value when considering all permutations:
+                // int?, int?(null value), int, object, object(null value)
                 value is not null)
             {
 
@@ -433,11 +444,12 @@ internal bool TryWrite(Utf8JsonWriter writer, in T value, JsonSerializerOptions
 
                 if (
 #if NET5_0_OR_GREATER
-                    !typeof(T).IsValueType && // treated as a constant by recent versions of the JIT.
+                    // Short-circuit the check against ignoreCyclesPopReference; treated as a constant by recent versions of the JIT.
+                    !typeof(T).IsValueType &&
 #endif
                     ignoreCyclesPopReference)
                 {
-                    // should only be entered if we're serializing instances
+                    // Should only be entered if we're serializing instances
                     // of type object using the internal object converter.
                     Debug.Assert(value?.GetType() == typeof(object) && IsInternalConverter);
                     state.ReferenceResolver.PopReferenceForCycleDetection();

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonSerializer.Helpers.cs

@@ -13,10 +13,14 @@ public static partial class JsonSerializer
         internal const string SerializationUnreferencedCodeMessage = "JSON serialization and deserialization might require types that cannot be statically analyzed. Use the overload that takes a JsonTypeInfo or JsonSerializerContext, or make sure all of the required types are preserved.";
 
         [RequiresUnreferencedCode(SerializationUnreferencedCodeMessage)]
-        private static JsonTypeInfo GetTypeInfo(Type runtimeType, JsonSerializerOptions? options)
+        private static JsonTypeInfo GetTypeInfo(JsonSerializerOptions? options, Type runtimeType)
         {
             options ??= JsonSerializerOptions.s_defaultOptions;
-            options.RootBuiltInConvertersAndTypeInfoCreator();
+            if (!options.IsInitializedForReflectionSerializer)
+            {
+                options.InitializeForReflectionSerializer();
+            }
+
             return options.GetOrAddClassForRootType(runtimeType);
         }
 

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonSerializer.Read.Document.cs

@@ -33,7 +33,8 @@ public static partial class JsonSerializer
                 throw new ArgumentNullException(nameof(document));
             }
 
-            return ReadUsingOptions<TValue>(document, typeof(TValue), options);
+            JsonTypeInfo jsonTypeInfo = GetTypeInfo(options, typeof(TValue));
+            return ReadDocument<TValue>(document, jsonTypeInfo);
         }
 
         /// <summary>
@@ -66,7 +67,8 @@ public static partial class JsonSerializer
                 throw new ArgumentNullException(nameof(returnType));
             }
 
-            return ReadUsingOptions<object?>(document, returnType, options);
+            JsonTypeInfo jsonTypeInfo = GetTypeInfo(options, returnType);
+            return ReadDocument<object?>(document, jsonTypeInfo);
         }
 
         /// <summary>
@@ -101,7 +103,7 @@ public static partial class JsonSerializer
                 throw new ArgumentNullException(nameof(jsonTypeInfo));
             }
 
-            return ReadUsingMetadata<TValue>(document, jsonTypeInfo);
+            return ReadDocument<TValue>(document, jsonTypeInfo);
         }
 
         /// <summary>
@@ -157,17 +159,14 @@ public static partial class JsonSerializer
                 throw new ArgumentNullException(nameof(context));
             }
 
-            return ReadUsingMetadata<object?>(document, GetTypeInfo(context, returnType));
+            JsonTypeInfo jsonTypeInfo = GetTypeInfo(context, returnType);
+            return ReadDocument<object?>(document, jsonTypeInfo);
         }
 
-        [RequiresUnreferencedCode(SerializationUnreferencedCodeMessage)]
-        private static TValue? ReadUsingOptions<TValue>(JsonDocument document, Type returnType, JsonSerializerOptions? options) =>
-            ReadUsingMetadata<TValue>(document, GetTypeInfo(returnType, options));
-
-        private static TValue? ReadUsingMetadata<TValue>(JsonDocument document, JsonTypeInfo jsonTypeInfo)
+        private static TValue? ReadDocument<TValue>(JsonDocument document, JsonTypeInfo jsonTypeInfo)
         {
             ReadOnlySpan<byte> utf8Json = document.GetRootRawValue().Span;
-            return ReadUsingMetadata<TValue>(utf8Json, jsonTypeInfo);
+            return ReadSpan<TValue>(utf8Json, jsonTypeInfo);
         }
     }
 }

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonSerializer.Read.Element.cs

@@ -23,8 +23,11 @@ public static partial class JsonSerializer
         /// for <typeparamref name="TValue"/> or its serializable members.
         /// </exception>
         [RequiresUnreferencedCode(SerializationUnreferencedCodeMessage)]
-        public static TValue? Deserialize<TValue>(this JsonElement element, JsonSerializerOptions? options = null) =>
-            ReadUsingOptions<TValue>(element, typeof(TValue), options);
+        public static TValue? Deserialize<TValue>(this JsonElement element, JsonSerializerOptions? options = null)
+        {
+            JsonTypeInfo jsonTypeInfo = GetTypeInfo(options, typeof(TValue));
+            return ReadUsingMetadata<TValue>(element, jsonTypeInfo);
+        }
 
         /// <summary>
         /// Converts the <see cref="JsonElement"/> representing a single JSON value into a <paramref name="returnType"/>.
@@ -51,7 +54,8 @@ public static partial class JsonSerializer
                 throw new ArgumentNullException(nameof(returnType));
             }
 
-            return ReadUsingOptions<object?>(element, returnType, options);
+            JsonTypeInfo jsonTypeInfo = GetTypeInfo(options, returnType);
+            return ReadUsingMetadata<object?>(element, jsonTypeInfo);
         }
 
         /// <summary>
@@ -124,17 +128,14 @@ public static partial class JsonSerializer
                 throw new ArgumentNullException(nameof(context));
             }
 
-            return ReadUsingMetadata<object?>(element, GetTypeInfo(context, returnType));
+            JsonTypeInfo jsonTypeInfo = GetTypeInfo(context, returnType);
+            return ReadUsingMetadata<object?>(element, jsonTypeInfo);
         }
 
-        [RequiresUnreferencedCode(SerializationUnreferencedCodeMessage)]
-        private static TValue? ReadUsingOptions<TValue>(JsonElement element, Type returnType, JsonSerializerOptions? options) =>
-            ReadUsingMetadata<TValue>(element, GetTypeInfo(returnType, options));
-
         private static TValue? ReadUsingMetadata<TValue>(JsonElement element, JsonTypeInfo jsonTypeInfo)
         {
             ReadOnlySpan<byte> utf8Json = element.GetRawValue().Span;
-            return ReadUsingMetadata<TValue>(utf8Json, jsonTypeInfo);
+            return ReadSpan<TValue>(utf8Json, jsonTypeInfo);
         }
     }
 }

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonSerializer.Read.Helpers.cs

@@ -20,10 +20,10 @@ public static partial class JsonSerializer
             // The non-generic API was called or we have a polymorphic case where TValue is not equal to the T in JsonConverter<T>.
             object? value = jsonConverter.ReadCoreAsObject(ref reader, options, ref state);
             Debug.Assert(value == null || value is TValue);
-            return (TValue)value!;
+            return (TValue?)value;
         }
 
-        private static TValue? ReadUsingMetadata<TValue>(ReadOnlySpan<byte> utf8Json, JsonTypeInfo jsonTypeInfo, int? actualByteCount = null)
+        private static TValue? ReadSpan<TValue>(ReadOnlySpan<byte> utf8Json, JsonTypeInfo jsonTypeInfo, int? actualByteCount = null)
         {
             JsonSerializerOptions options = jsonTypeInfo.Options;
 
@@ -33,7 +33,22 @@ public static partial class JsonSerializer
             ReadStack state = default;
             state.Initialize(jsonTypeInfo);
 
-            TValue? value = ReadCore<TValue>(jsonTypeInfo.PropertyInfoForTypeInfo.ConverterBase, ref reader, options, ref state);
+            TValue? value;
+            JsonConverter jsonConverter = jsonTypeInfo.PropertyInfoForTypeInfo.ConverterBase;
+
+            // For performance, the code below is a lifted ReadCore() above.
+            if (jsonConverter is JsonConverter<TValue> converter)
+            {
+                // Call the strongly-typed ReadCore that will not box structs.
+                value = converter.ReadCore(ref reader, options, ref state);
+            }
+            else
+            {
+                // The non-generic API was called or we have a polymorphic case where TValue is not equal to the T in JsonConverter<T>.
+                object? objValue = jsonConverter.ReadCoreAsObject(ref reader, options, ref state);
+                Debug.Assert(objValue == null || objValue is TValue);
+                value = (TValue?)objValue;
+            }
 
             // The reader should have thrown if we have remaining bytes.
             Debug.Assert(reader.BytesConsumed == (actualByteCount ?? utf8Json.Length));

src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonSerializer.Read.Node.cs

@@ -27,7 +27,8 @@ public static partial class JsonSerializer
         [RequiresUnreferencedCode(SerializationUnreferencedCodeMessage)]
         public static TValue? Deserialize<TValue>(this JsonNode? node, JsonSerializerOptions? options = null)
         {
-            return ReadUsingOptions<TValue>(node, typeof(TValue), options);
+            JsonTypeInfo jsonTypeInfo = GetTypeInfo(options, typeof(TValue));
+            return ReadNode<TValue>(node, jsonTypeInfo);
         }
 
         /// <summary>
@@ -52,7 +53,8 @@ public static partial class JsonSerializer
                 throw new ArgumentNullException(nameof(returnType));
             }
 
-            return ReadUsingOptions<object?>(node, returnType, options);
+            JsonTypeInfo jsonTypeInfo = GetTypeInfo(options, returnType);
+            return ReadNode<object?>(node, jsonTypeInfo);
         }
 
         /// <summary>
@@ -78,7 +80,7 @@ public static partial class JsonSerializer
                 throw new ArgumentNullException(nameof(jsonTypeInfo));
             }
 
-            return ReadUsingMetadata<TValue>(node, jsonTypeInfo);
+            return ReadNode<TValue>(node, jsonTypeInfo);
         }
 
         /// <summary>
@@ -125,17 +127,13 @@ public static partial class JsonSerializer
                 throw new ArgumentNullException(nameof(context));
             }
 
-            return ReadUsingMetadata<object?>(node, GetTypeInfo(context, returnType));
+            JsonTypeInfo jsonTypeInfo = GetTypeInfo(context, returnType);
+            return ReadNode<object?>(node, jsonTypeInfo);
         }
 
-        [RequiresUnreferencedCode(SerializationUnreferencedCodeMessage)]
-        private static TValue? ReadUsingOptions<TValue>(JsonNode? node, Type returnType, JsonSerializerOptions? options) =>
-            ReadUsingMetadata<TValue>(node, GetTypeInfo(returnType, options));
-
-        private static TValue? ReadUsingMetadata<TValue>(JsonNode? node, JsonTypeInfo jsonTypeInfo)
+        private static TValue? ReadNode<TValue>(JsonNode? node, JsonTypeInfo jsonTypeInfo)
         {
             JsonSerializerOptions options = jsonTypeInfo.Options;
-            Debug.Assert(options != null);
 
             // For performance, share the same buffer across serialization and deserialization.
             using var output = new PooledByteBufferWriter(options.DefaultBufferSize);
@@ -151,7 +149,7 @@ public static partial class JsonSerializer
                 }
             }
 
-            return ReadUsingMetadata<TValue>(output.WrittenMemory.Span, jsonTypeInfo);
+            return ReadSpan<TValue>(output.WrittenMemory.Span, jsonTypeInfo);
         }
     }
 }