Handling of Nullable<T> should be done by System.Text.Json

Author: PawelGerr

Directory.Build.props

@@ -2,7 +2,7 @@
 
    <PropertyGroup>
       <Copyright>(c) $([System.DateTime]::Now.Year), Pawel Gerr. All rights reserved.</Copyright>
-      <VersionPrefix>7.2.1</VersionPrefix>
+      <VersionPrefix>7.2.2</VersionPrefix>
       <Authors>Pawel Gerr</Authors>
       <GenerateDocumentationFile>true</GenerateDocumentationFile>
       <PackageProjectUrl>https://github.com/PawelGerr/Thinktecture.Runtime.Extensions</PackageProjectUrl>

src/Thinktecture.Runtime.Extensions.Json/Text/Json/Serialization/ValueObjectJsonConverterFactory.cs

@@ -60,6 +60,10 @@ public sealed class ValueObjectJsonConverterFactory : JsonConverterFactory
    /// <inheritdoc />
    public override bool CanConvert(Type typeToConvert)
    {
+      // Handling of Nullable<T> should be done by System.Text.Json
+      if (typeToConvert.IsValueType && Nullable.GetUnderlyingType(typeToConvert) is not null)
+         return false;
+
       return KeyedValueObjectMetadataLookup.Find(typeToConvert) is not null
              || typeToConvert.GetCustomAttributes<ValueObjectFactoryAttribute>().Any(a => a.UseForSerialization.HasFlag(SerializationFrameworks.SystemTextJson));
    }

test/Thinktecture.Runtime.Extensions.Json.Tests/Text/Json/Serialization/ValueObjectJsonConverterFactoryTests/RoundTrip.cs

@@ -200,10 +200,10 @@ public void Should_deserialize_decimal_from_string_with_corresponding_NumberHand
    public void Should_roundtrip_serialize_dictionary_with_string_based_enum_key()
    {
       var dictionary = new Dictionary<TestSmartEnum_Class_StringBased, int>
-                       {
-                          { TestSmartEnum_Class_StringBased.Value1, 1 },
-                          { TestSmartEnum_Class_StringBased.Value2, 2 }
-                       };
+      {
+         { TestSmartEnum_Class_StringBased.Value1, 1 },
+         { TestSmartEnum_Class_StringBased.Value2, 2 }
+      };
 
       var options = new JsonSerializerOptions { Converters = { new ValueObjectJsonConverterFactory() } };
 
@@ -212,4 +212,37 @@ public void Should_roundtrip_serialize_dictionary_with_string_based_enum_key()
 
       dictionary.Should().BeEquivalentTo(deserializedDictionary);
    }
+
+   public static IEnumerable<object[]> ObjectWithStructTestData =
+   [
+      [new { Prop = IntBasedStructValueObject.Create(42) }, """{"Prop":42}"""],
+      [new { Prop = (IntBasedStructValueObject?)IntBasedStructValueObject.Create(42) }, """{"Prop":42}"""],
+      [new { Prop = IntBasedReferenceValueObject.Create(42) }, """{"Prop":42}"""],
+      [new TestStruct<IntBasedStructValueObject>(IntBasedStructValueObject.Create(42)), """{"Prop":42}"""],
+      [new TestStruct<IntBasedStructValueObject?>(IntBasedStructValueObject.Create(42)), """{"Prop":42}"""],
+      [new TestStruct<IntBasedReferenceValueObject>(IntBasedReferenceValueObject.Create(42)), """{"Prop":42}"""],
+   ];
+
+   [Theory]
+   [MemberData(nameof(ObjectWithStructTestData))]
+   public void Should_roundtrip_serialize_types_with_struct_properties_using_non_generic_factory(object obj, string expectedJson)
+   {
+      var options = new JsonSerializerOptions { Converters = { new ValueObjectJsonConverterFactory() } };
+
+      var json = JsonSerializer.Serialize(obj, options);
+      json.Should().Be(expectedJson);
+
+      var deserializedObj = JsonSerializer.Deserialize(json, obj.GetType(), options);
+      obj.Should().BeEquivalentTo(deserializedObj);
+   }
+
+   private struct TestStruct<T>
+   {
+      public T Prop { get; set; }
+
+      public TestStruct(T prop)
+      {
+         Prop = prop;
+      }
+   }
 }