Fix primitive converters to honor JsonNumberHandling when obtained via GetConverter (#120805)

Copilot · eiriktsarpalis · stephentoub · web-flow · commit 23b6046b8b75 · 2026-01-23T00:24:49.000Z
Co-authored-by: copilot-swe-agent[bot] &lt;198982749+Copilot@users.noreply.github.com&gt;
Co-authored-by: eiriktsarpalis &lt;2813363+eiriktsarpalis@users.noreply.github.com&gt;
Co-authored-by: stephentoub &lt;2642209+stephentoub@users.noreply.github.com&gt;
Co-authored-by: Eirik Tsarpalis &lt;eirik.tsarpalis@gmail.com&gt;
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Value/ByteConverter.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Value/ByteConverter.cs
@@ -16,11 +16,22 @@ public ByteConverter()
 
         public override byte Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
         {
+            if (options?.NumberHandling is not null and not JsonNumberHandling.Strict)
+            {
+                return ReadNumberWithCustomHandling(ref reader, options.NumberHandling, options);
+            }
+
             return reader.GetByte();
         }
 
         public override void Write(Utf8JsonWriter writer, byte value, JsonSerializerOptions options)
         {
+            if (options?.NumberHandling is not null and not JsonNumberHandling.Strict)
+            {
+                WriteNumberWithCustomHandling(writer, value, options.NumberHandling);
+                return;
+            }
+
             writer.WriteNumberValue(value);
         }
 
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Value/DecimalConverter.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Value/DecimalConverter.cs
@@ -15,11 +15,22 @@ public DecimalConverter()
 
         public override decimal Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
         {
+            if (options?.NumberHandling is not null and not JsonNumberHandling.Strict)
+            {
+                return ReadNumberWithCustomHandling(ref reader, options.NumberHandling, options);
+            }
+
             return reader.GetDecimal();
         }
 
         public override void Write(Utf8JsonWriter writer, decimal value, JsonSerializerOptions options)
         {
+            if (options?.NumberHandling is not null and not JsonNumberHandling.Strict)
+            {
+                WriteNumberWithCustomHandling(writer, value, options.NumberHandling);
+                return;
+            }
+
             writer.WriteNumberValue(value);
         }
 
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Value/DoubleConverter.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Value/DoubleConverter.cs
@@ -16,11 +16,22 @@ public DoubleConverter()
 
         public override double Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
         {
+            if (options?.NumberHandling is not null and not JsonNumberHandling.Strict)
+            {
+                return ReadNumberWithCustomHandling(ref reader, options.NumberHandling, options);
+            }
+
             return reader.GetDouble();
         }
 
         public override void Write(Utf8JsonWriter writer, double value, JsonSerializerOptions options)
         {
+            if (options?.NumberHandling is not null and not JsonNumberHandling.Strict)
+            {
+                WriteNumberWithCustomHandling(writer, value, options.NumberHandling);
+                return;
+            }
+
             writer.WriteNumberValue(value);
         }
 
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Value/HalfConverter.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Value/HalfConverter.cs
@@ -21,6 +21,11 @@ public HalfConverter()
 
         public override Half Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
         {
+            if (options?.NumberHandling is not null and not JsonNumberHandling.Strict)
+            {
+                return ReadNumberWithCustomHandling(ref reader, options.NumberHandling, options);
+            }
+
             if (reader.TokenType != JsonTokenType.Number)
             {
                 ThrowHelper.ThrowInvalidOperationException_ExpectedNumber(reader.TokenType);
@@ -31,6 +36,12 @@ public override Half Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSer
 
         public override void Write(Utf8JsonWriter writer, Half value, JsonSerializerOptions options)
         {
+            if (options?.NumberHandling is not null and not JsonNumberHandling.Strict)
+            {
+                WriteNumberWithCustomHandling(writer, value, options.NumberHandling);
+                return;
+            }
+
             WriteCore(writer, value);
         }
 
@@ -107,7 +118,12 @@ internal override Half ReadNumberWithCustomHandling(ref Utf8JsonReader reader, J
                 }
             }
 
-            return Read(ref reader, Type, options);
+            if (reader.TokenType != JsonTokenType.Number)
+            {
+                ThrowHelper.ThrowInvalidOperationException_ExpectedNumber(reader.TokenType);
+            }
+
+            return ReadCore(ref reader);
         }
 
         internal override void WriteNumberWithCustomHandling(Utf8JsonWriter writer, Half value, JsonNumberHandling handling)
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Value/Int128Converter.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Value/Int128Converter.cs
@@ -20,6 +20,11 @@ public Int128Converter()
 
         public override Int128 Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
         {
+            if (options?.NumberHandling is not null and not JsonNumberHandling.Strict)
+            {
+                return ReadNumberWithCustomHandling(ref reader, options.NumberHandling, options);
+            }
+
             if (reader.TokenType != JsonTokenType.Number)
             {
                 ThrowHelper.ThrowInvalidOperationException_ExpectedNumber(reader.TokenType);
@@ -30,6 +35,12 @@ public override Int128 Read(ref Utf8JsonReader reader, Type typeToConvert, JsonS
 
         public override void Write(Utf8JsonWriter writer, Int128 value, JsonSerializerOptions options)
         {
+            if (options?.NumberHandling is not null and not JsonNumberHandling.Strict)
+            {
+                WriteNumberWithCustomHandling(writer, value, options.NumberHandling);
+                return;
+            }
+
             WriteCore(writer, value);
         }
 
@@ -84,7 +95,12 @@ internal override Int128 ReadNumberWithCustomHandling(ref Utf8JsonReader reader,
                 return ReadCore(ref reader);
             }
 
-            return Read(ref reader, Type, options);
+            if (reader.TokenType != JsonTokenType.Number)
+            {
+                ThrowHelper.ThrowInvalidOperationException_ExpectedNumber(reader.TokenType);
+            }
+
+            return ReadCore(ref reader);
         }
 
         internal override void WriteNumberWithCustomHandling(Utf8JsonWriter writer, Int128 value, JsonNumberHandling handling)
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Value/Int16Converter.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Value/Int16Converter.cs
@@ -16,11 +16,22 @@ public Int16Converter()
 
         public override short Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
         {
+            if (options?.NumberHandling is not null and not JsonNumberHandling.Strict)
+            {
+                return ReadNumberWithCustomHandling(ref reader, options.NumberHandling, options);
+            }
+
             return reader.GetInt16();
         }
 
         public override void Write(Utf8JsonWriter writer, short value, JsonSerializerOptions options)
         {
+            if (options?.NumberHandling is not null and not JsonNumberHandling.Strict)
+            {
+                WriteNumberWithCustomHandling(writer, value, options.NumberHandling);
+                return;
+            }
+
             // For performance, lift up the writer implementation.
             writer.WriteNumberValue((long)value);
         }
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Value/Int32Converter.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Value/Int32Converter.cs
@@ -16,11 +16,22 @@ public Int32Converter()
 
         public override int Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
         {
+            if (options?.NumberHandling is not null and not JsonNumberHandling.Strict)
+            {
+                return ReadNumberWithCustomHandling(ref reader, options.NumberHandling, options);
+            }
+
             return reader.GetInt32();
         }
 
         public override void Write(Utf8JsonWriter writer, int value, JsonSerializerOptions options)
         {
+            if (options?.NumberHandling is not null and not JsonNumberHandling.Strict)
+            {
+                WriteNumberWithCustomHandling(writer, value, options.NumberHandling);
+                return;
+            }
+
             // For performance, lift up the writer implementation.
             writer.WriteNumberValue((long)value);
         }
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Value/Int64Converter.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Value/Int64Converter.cs
@@ -16,11 +16,22 @@ public Int64Converter()
 
         public override long Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
         {
+            if (options?.NumberHandling is not null and not JsonNumberHandling.Strict)
+            {
+                return ReadNumberWithCustomHandling(ref reader, options.NumberHandling, options);
+            }
+
             return reader.GetInt64();
         }
 
         public override void Write(Utf8JsonWriter writer, long value, JsonSerializerOptions options)
         {
+            if (options?.NumberHandling is not null and not JsonNumberHandling.Strict)
+            {
+                WriteNumberWithCustomHandling(writer, value, options.NumberHandling);
+                return;
+            }
+
             writer.WriteNumberValue(value);
         }
 
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Value/SByteConverter.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Value/SByteConverter.cs
@@ -16,11 +16,22 @@ public SByteConverter()
 
         public override sbyte Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
         {
+            if (options?.NumberHandling is not null and not JsonNumberHandling.Strict)
+            {
+                return ReadNumberWithCustomHandling(ref reader, options.NumberHandling, options);
+            }
+
             return reader.GetSByte();
         }
 
         public override void Write(Utf8JsonWriter writer, sbyte value, JsonSerializerOptions options)
         {
+            if (options?.NumberHandling is not null and not JsonNumberHandling.Strict)
+            {
+                WriteNumberWithCustomHandling(writer, value, options.NumberHandling);
+                return;
+            }
+
             writer.WriteNumberValue(value);
         }
 
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Value/SingleConverter.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Value/SingleConverter.cs
@@ -17,11 +17,22 @@ public SingleConverter()
 
         public override float Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
         {
+            if (options?.NumberHandling is not null and not JsonNumberHandling.Strict)
+            {
+                return ReadNumberWithCustomHandling(ref reader, options.NumberHandling, options);
+            }
+
             return reader.GetSingle();
         }
 
         public override void Write(Utf8JsonWriter writer, float value, JsonSerializerOptions options)
         {
+            if (options?.NumberHandling is not null and not JsonNumberHandling.Strict)
+            {
+                WriteNumberWithCustomHandling(writer, value, options.NumberHandling);
+                return;
+            }
+
             writer.WriteNumberValue(value);
         }
 
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Value/UInt128Converter.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Value/UInt128Converter.cs
@@ -20,6 +20,11 @@ public UInt128Converter()
 
         public override UInt128 Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
         {
+            if (options?.NumberHandling is not null and not JsonNumberHandling.Strict)
+            {
+                return ReadNumberWithCustomHandling(ref reader, options.NumberHandling, options);
+            }
+
             if (reader.TokenType != JsonTokenType.Number)
             {
                 ThrowHelper.ThrowInvalidOperationException_ExpectedNumber(reader.TokenType);
@@ -30,6 +35,12 @@ public override UInt128 Read(ref Utf8JsonReader reader, Type typeToConvert, Json
 
         public override void Write(Utf8JsonWriter writer, UInt128 value, JsonSerializerOptions options)
         {
+            if (options?.NumberHandling is not null and not JsonNumberHandling.Strict)
+            {
+                WriteNumberWithCustomHandling(writer, value, options.NumberHandling);
+                return;
+            }
+
             WriteCore(writer, value);
         }
 
@@ -84,7 +95,12 @@ internal override UInt128 ReadNumberWithCustomHandling(ref Utf8JsonReader reader
                 return ReadCore(ref reader);
             }
 
-            return Read(ref reader, Type, options);
+            if (reader.TokenType != JsonTokenType.Number)
+            {
+                ThrowHelper.ThrowInvalidOperationException_ExpectedNumber(reader.TokenType);
+            }
+
+            return ReadCore(ref reader);
         }
 
         internal override void WriteNumberWithCustomHandling(Utf8JsonWriter writer, UInt128 value, JsonNumberHandling handling)
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Value/UInt16Converter.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Value/UInt16Converter.cs
@@ -16,11 +16,22 @@ public UInt16Converter()
 
         public override ushort Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
         {
+            if (options?.NumberHandling is not null and not JsonNumberHandling.Strict)
+            {
+                return ReadNumberWithCustomHandling(ref reader, options.NumberHandling, options);
+            }
+
             return reader.GetUInt16();
         }
 
         public override void Write(Utf8JsonWriter writer, ushort value, JsonSerializerOptions options)
         {
+            if (options?.NumberHandling is not null and not JsonNumberHandling.Strict)
+            {
+                WriteNumberWithCustomHandling(writer, value, options.NumberHandling);
+                return;
+            }
+
             // For performance, lift up the writer implementation.
             writer.WriteNumberValue((long)value);
         }
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Value/UInt32Converter.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Value/UInt32Converter.cs
@@ -16,11 +16,22 @@ public UInt32Converter()
 
         public override uint Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
         {
+            if (options?.NumberHandling is not null and not JsonNumberHandling.Strict)
+            {
+                return ReadNumberWithCustomHandling(ref reader, options.NumberHandling, options);
+            }
+
             return reader.GetUInt32();
         }
 
         public override void Write(Utf8JsonWriter writer, uint value, JsonSerializerOptions options)
         {
+            if (options?.NumberHandling is not null and not JsonNumberHandling.Strict)
+            {
+                WriteNumberWithCustomHandling(writer, value, options.NumberHandling);
+                return;
+            }
+
             // For performance, lift up the writer implementation.
             writer.WriteNumberValue((ulong)value);
         }
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Value/UInt64Converter.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Value/UInt64Converter.cs
@@ -16,11 +16,22 @@ public UInt64Converter()
 
         public override ulong Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
         {
+            if (options?.NumberHandling is not null and not JsonNumberHandling.Strict)
+            {
+                return ReadNumberWithCustomHandling(ref reader, options.NumberHandling, options);
+            }
+
             return reader.GetUInt64();
         }
 
         public override void Write(Utf8JsonWriter writer, ulong value, JsonSerializerOptions options)
         {
+            if (options?.NumberHandling is not null and not JsonNumberHandling.Strict)
+            {
+                WriteNumberWithCustomHandling(writer, value, options.NumberHandling);
+                return;
+            }
+
             writer.WriteNumberValue(value);
         }
 
diff --git a/src/libraries/System.Text.Json/tests/Common/NumberHandlingTests.cs b/src/libraries/System.Text.Json/tests/Common/NumberHandlingTests.cs

Original file line number	Diff line number	Diff line change
`@@ -16,11 +16,22 @@ public ByteConverter()`
`16`	`16`
`17`	`17`	`public override byte Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)`
`18`	`18`	`{`
	`19`	`+ if (options?.NumberHandling is not null and not JsonNumberHandling.Strict)`
	`20`	`+ {`
	`21`	`+ return ReadNumberWithCustomHandling(ref reader, options.NumberHandling, options);`
	`22`	`+ }`
	`23`	`+`
`19`	`24`	`return reader.GetByte();`
`20`	`25`	`}`
`21`	`26`
`22`	`27`	`public override void Write(Utf8JsonWriter writer, byte value, JsonSerializerOptions options)`
`23`	`28`	`{`
	`29`	`+ if (options?.NumberHandling is not null and not JsonNumberHandling.Strict)`
	`30`	`+ {`
	`31`	`+ WriteNumberWithCustomHandling(writer, value, options.NumberHandling);`
	`32`	`+ return;`
	`33`	`+ }`
	`34`	`+`
`24`	`35`	`writer.WriteNumberValue(value);`
`25`	`36`	`}`
`26`	`37`
Original file line number	Diff line number	Diff line change
`@@ -15,11 +15,22 @@ public DecimalConverter()`
`15`	`15`
`16`	`16`	`public override decimal Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)`
`17`	`17`	`{`
	`18`	`+ if (options?.NumberHandling is not null and not JsonNumberHandling.Strict)`
	`19`	`+ {`
	`20`	`+ return ReadNumberWithCustomHandling(ref reader, options.NumberHandling, options);`
	`21`	`+ }`
	`22`	`+`
`18`	`23`	`return reader.GetDecimal();`
`19`	`24`	`}`
`20`	`25`
`21`	`26`	`public override void Write(Utf8JsonWriter writer, decimal value, JsonSerializerOptions options)`
`22`	`27`	`{`
	`28`	`+ if (options?.NumberHandling is not null and not JsonNumberHandling.Strict)`
	`29`	`+ {`
	`30`	`+ WriteNumberWithCustomHandling(writer, value, options.NumberHandling);`
	`31`	`+ return;`
	`32`	`+ }`
	`33`	`+`
`23`	`34`	`writer.WriteNumberValue(value);`
`24`	`35`	`}`
`25`	`36`
Original file line number	Diff line number	Diff line change
`@@ -16,11 +16,22 @@ public DoubleConverter()`
`16`	`16`
`17`	`17`	`public override double Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)`
`18`	`18`	`{`
	`19`	`+ if (options?.NumberHandling is not null and not JsonNumberHandling.Strict)`
	`20`	`+ {`
	`21`	`+ return ReadNumberWithCustomHandling(ref reader, options.NumberHandling, options);`
	`22`	`+ }`
	`23`	`+`
`19`	`24`	`return reader.GetDouble();`
`20`	`25`	`}`
`21`	`26`
`22`	`27`	`public override void Write(Utf8JsonWriter writer, double value, JsonSerializerOptions options)`
`23`	`28`	`{`
	`29`	`+ if (options?.NumberHandling is not null and not JsonNumberHandling.Strict)`
	`30`	`+ {`
	`31`	`+ WriteNumberWithCustomHandling(writer, value, options.NumberHandling);`
	`32`	`+ return;`
	`33`	`+ }`
	`34`	`+`
`24`	`35`	`writer.WriteNumberValue(value);`
`25`	`36`	`}`
`26`	`37`
Original file line number	Diff line number	Diff line change
`@@ -21,6 +21,11 @@ public HalfConverter()`
`21`	`21`
`22`	`22`	`public override Half Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)`
`23`	`23`	`{`
	`24`	`+ if (options?.NumberHandling is not null and not JsonNumberHandling.Strict)`
	`25`	`+ {`
	`26`	`+ return ReadNumberWithCustomHandling(ref reader, options.NumberHandling, options);`
	`27`	`+ }`
	`28`	`+`
`24`	`29`	`if (reader.TokenType != JsonTokenType.Number)`
`25`	`30`	`{`
`26`	`31`	`ThrowHelper.ThrowInvalidOperationException_ExpectedNumber(reader.TokenType);`
`@@ -31,6 +36,12 @@ public override Half Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSer`
`31`	`36`
`32`	`37`	`public override void Write(Utf8JsonWriter writer, Half value, JsonSerializerOptions options)`
`33`	`38`	`{`
	`39`	`+ if (options?.NumberHandling is not null and not JsonNumberHandling.Strict)`
	`40`	`+ {`
	`41`	`+ WriteNumberWithCustomHandling(writer, value, options.NumberHandling);`
	`42`	`+ return;`
	`43`	`+ }`
	`44`	`+`
`34`	`45`	`WriteCore(writer, value);`
`35`	`46`	`}`
`36`	`47`
`@@ -107,7 +118,12 @@ internal override Half ReadNumberWithCustomHandling(ref Utf8JsonReader reader, J`
`107`	`118`	`}`
`108`	`119`	`}`
`109`	`120`
`110`		`- return Read(ref reader, Type, options);`
	`121`	`+ if (reader.TokenType != JsonTokenType.Number)`
	`122`	`+ {`
	`123`	`+ ThrowHelper.ThrowInvalidOperationException_ExpectedNumber(reader.TokenType);`
	`124`	`+ }`
	`125`	`+`
	`126`	`+ return ReadCore(ref reader);`
`111`	`127`	`}`
`112`	`128`
`113`	`129`	`internal override void WriteNumberWithCustomHandling(Utf8JsonWriter writer, Half value, JsonNumberHandling handling)`
Original file line number	Diff line number	Diff line change
`@@ -20,6 +20,11 @@ public Int128Converter()`
`20`	`20`
`21`	`21`	`public override Int128 Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)`
`22`	`22`	`{`
	`23`	`+ if (options?.NumberHandling is not null and not JsonNumberHandling.Strict)`
	`24`	`+ {`
	`25`	`+ return ReadNumberWithCustomHandling(ref reader, options.NumberHandling, options);`
	`26`	`+ }`
	`27`	`+`
`23`	`28`	`if (reader.TokenType != JsonTokenType.Number)`
`24`	`29`	`{`
`25`	`30`	`ThrowHelper.ThrowInvalidOperationException_ExpectedNumber(reader.TokenType);`
`@@ -30,6 +35,12 @@ public override Int128 Read(ref Utf8JsonReader reader, Type typeToConvert, JsonS`
`30`	`35`
`31`	`36`	`public override void Write(Utf8JsonWriter writer, Int128 value, JsonSerializerOptions options)`
`32`	`37`	`{`
	`38`	`+ if (options?.NumberHandling is not null and not JsonNumberHandling.Strict)`
	`39`	`+ {`
	`40`	`+ WriteNumberWithCustomHandling(writer, value, options.NumberHandling);`
	`41`	`+ return;`
	`42`	`+ }`
	`43`	`+`
`33`	`44`	`WriteCore(writer, value);`
`34`	`45`	`}`
`35`	`46`
`@@ -84,7 +95,12 @@ internal override Int128 ReadNumberWithCustomHandling(ref Utf8JsonReader reader,`
`84`	`95`	`return ReadCore(ref reader);`
`85`	`96`	`}`
`86`	`97`
`87`		`- return Read(ref reader, Type, options);`
	`98`	`+ if (reader.TokenType != JsonTokenType.Number)`
	`99`	`+ {`
	`100`	`+ ThrowHelper.ThrowInvalidOperationException_ExpectedNumber(reader.TokenType);`
	`101`	`+ }`
	`102`	`+`
	`103`	`+ return ReadCore(ref reader);`
`88`	`104`	`}`
`89`	`105`
`90`	`106`	`internal override void WriteNumberWithCustomHandling(Utf8JsonWriter writer, Int128 value, JsonNumberHandling handling)`
Original file line number	Diff line number	Diff line change
`@@ -16,11 +16,22 @@ public Int16Converter()`
`16`	`16`
`17`	`17`	`public override short Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)`
`18`	`18`	`{`
	`19`	`+ if (options?.NumberHandling is not null and not JsonNumberHandling.Strict)`
	`20`	`+ {`
	`21`	`+ return ReadNumberWithCustomHandling(ref reader, options.NumberHandling, options);`
	`22`	`+ }`
	`23`	`+`
`19`	`24`	`return reader.GetInt16();`
`20`	`25`	`}`
`21`	`26`
`22`	`27`	`public override void Write(Utf8JsonWriter writer, short value, JsonSerializerOptions options)`
`23`	`28`	`{`
	`29`	`+ if (options?.NumberHandling is not null and not JsonNumberHandling.Strict)`
	`30`	`+ {`
	`31`	`+ WriteNumberWithCustomHandling(writer, value, options.NumberHandling);`
	`32`	`+ return;`
	`33`	`+ }`
	`34`	`+`
`24`	`35`	`// For performance, lift up the writer implementation.`
`25`	`36`	`writer.WriteNumberValue((long)value);`
`26`	`37`	`}`
Original file line number	Diff line number	Diff line change
`@@ -16,11 +16,22 @@ public Int32Converter()`
`16`	`16`
`17`	`17`	`public override int Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)`
`18`	`18`	`{`
	`19`	`+ if (options?.NumberHandling is not null and not JsonNumberHandling.Strict)`
	`20`	`+ {`
	`21`	`+ return ReadNumberWithCustomHandling(ref reader, options.NumberHandling, options);`
	`22`	`+ }`
	`23`	`+`
`19`	`24`	`return reader.GetInt32();`
`20`	`25`	`}`
`21`	`26`
`22`	`27`	`public override void Write(Utf8JsonWriter writer, int value, JsonSerializerOptions options)`
`23`	`28`	`{`
	`29`	`+ if (options?.NumberHandling is not null and not JsonNumberHandling.Strict)`
	`30`	`+ {`
	`31`	`+ WriteNumberWithCustomHandling(writer, value, options.NumberHandling);`
	`32`	`+ return;`
	`33`	`+ }`
	`34`	`+`
`24`	`35`	`// For performance, lift up the writer implementation.`
`25`	`36`	`writer.WriteNumberValue((long)value);`
`26`	`37`	`}`
Original file line number	Diff line number	Diff line change
`@@ -16,11 +16,22 @@ public Int64Converter()`
`16`	`16`
`17`	`17`	`public override long Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)`
`18`	`18`	`{`
	`19`	`+ if (options?.NumberHandling is not null and not JsonNumberHandling.Strict)`
	`20`	`+ {`
	`21`	`+ return ReadNumberWithCustomHandling(ref reader, options.NumberHandling, options);`
	`22`	`+ }`
	`23`	`+`
`19`	`24`	`return reader.GetInt64();`
`20`	`25`	`}`
`21`	`26`
`22`	`27`	`public override void Write(Utf8JsonWriter writer, long value, JsonSerializerOptions options)`
`23`	`28`	`{`
	`29`	`+ if (options?.NumberHandling is not null and not JsonNumberHandling.Strict)`
	`30`	`+ {`
	`31`	`+ WriteNumberWithCustomHandling(writer, value, options.NumberHandling);`
	`32`	`+ return;`
	`33`	`+ }`
	`34`	`+`
`24`	`35`	`writer.WriteNumberValue(value);`
`25`	`36`	`}`
`26`	`37`
Original file line number	Diff line number	Diff line change
`@@ -16,11 +16,22 @@ public SByteConverter()`
`16`	`16`
`17`	`17`	`public override sbyte Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)`
`18`	`18`	`{`
	`19`	`+ if (options?.NumberHandling is not null and not JsonNumberHandling.Strict)`
	`20`	`+ {`
	`21`	`+ return ReadNumberWithCustomHandling(ref reader, options.NumberHandling, options);`
	`22`	`+ }`
	`23`	`+`
`19`	`24`	`return reader.GetSByte();`
`20`	`25`	`}`
`21`	`26`
`22`	`27`	`public override void Write(Utf8JsonWriter writer, sbyte value, JsonSerializerOptions options)`
`23`	`28`	`{`
	`29`	`+ if (options?.NumberHandling is not null and not JsonNumberHandling.Strict)`
	`30`	`+ {`
	`31`	`+ WriteNumberWithCustomHandling(writer, value, options.NumberHandling);`
	`32`	`+ return;`
	`33`	`+ }`
	`34`	`+`
`24`	`35`	`writer.WriteNumberValue(value);`
`25`	`36`	`}`
`26`	`37`
Original file line number	Diff line number	Diff line change
`@@ -17,11 +17,22 @@ public SingleConverter()`
`17`	`17`
`18`	`18`	`public override float Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)`
`19`	`19`	`{`
	`20`	`+ if (options?.NumberHandling is not null and not JsonNumberHandling.Strict)`
	`21`	`+ {`
	`22`	`+ return ReadNumberWithCustomHandling(ref reader, options.NumberHandling, options);`
	`23`	`+ }`
	`24`	`+`
`20`	`25`	`return reader.GetSingle();`
`21`	`26`	`}`
`22`	`27`
`23`	`28`	`public override void Write(Utf8JsonWriter writer, float value, JsonSerializerOptions options)`
`24`	`29`	`{`
	`30`	`+ if (options?.NumberHandling is not null and not JsonNumberHandling.Strict)`
	`31`	`+ {`
	`32`	`+ WriteNumberWithCustomHandling(writer, value, options.NumberHandling);`
	`33`	`+ return;`
	`34`	`+ }`
	`35`	`+`
`25`	`36`	`writer.WriteNumberValue(value);`
`26`	`37`	`}`
`27`	`38`