Non-generic ValueObjectJsonConverterFactory prioritizes JsonConverterAttribute over its own converter

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.2</VersionPrefix>
+      <VersionPrefix>7.3.0</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

@@ -57,15 +57,49 @@ public override JsonConverter CreateConverter(Type typeToConvert, JsonSerializer
 /// </summary>
 public sealed class ValueObjectJsonConverterFactory : JsonConverterFactory
 {
+   private readonly bool _skipValueObjectsWithJsonConverterAttribute;
+
+   /// <summary>
+   /// Initializes new instance of <see cref="ValueObjectJsonConverterFactory"/>.
+   /// </summary>
+   public ValueObjectJsonConverterFactory()
+      : this(true)
+   {
+   }
+
+   /// <summary>
+   /// Initializes new instance of <see cref="ValueObjectJsonConverterFactory"/>.
+   /// </summary>
+   /// <param name="skipValueObjectsWithJsonConverterAttribute">
+   /// Indication whether to skip value objects with <see cref="JsonConverterAttribute"/>.
+   /// </param>
+   public ValueObjectJsonConverterFactory(
+      bool skipValueObjectsWithJsonConverterAttribute)
+   {
+      _skipValueObjectsWithJsonConverterAttribute = skipValueObjectsWithJsonConverterAttribute;
+   }
+
    /// <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));
+      var valueObjectType = GetValueObjectType(typeToConvert);
+
+      if (valueObjectType is null)
+         return false;
+
+      return !_skipValueObjectsWithJsonConverterAttribute || !valueObjectType.GetCustomAttributes<JsonConverterAttribute>().Any();
+   }
+
+   private static Type? GetValueObjectType(Type typeToConvert)
+   {
+      if (typeToConvert.GetCustomAttributes<ValueObjectFactoryAttribute>().Any(a => a.UseForSerialization.HasFlag(SerializationFrameworks.SystemTextJson)))
+         return typeToConvert;
+
+      return KeyedValueObjectMetadataLookup.Find(typeToConvert)?.Type;
    }
 
    /// <inheritdoc />

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

@@ -225,9 +225,20 @@ [new TestStruct<IntBasedReferenceValueObject>(IntBasedReferenceValueObject.Creat
 
    [Theory]
    [MemberData(nameof(ObjectWithStructTestData))]
-   public void Should_roundtrip_serialize_types_with_struct_properties_using_non_generic_factory(object obj, string expectedJson)
+   public void Should_roundtrip_serialize_types_with_struct_properties_using_non_generic_factory(
+      object obj,
+      string expectedJson)
    {
-      var options = new JsonSerializerOptions { Converters = { new ValueObjectJsonConverterFactory() } };
+      Roundtrip_serialize_types_with_struct_properties_using_non_generic_factory(true, obj, expectedJson);
+      Roundtrip_serialize_types_with_struct_properties_using_non_generic_factory(false, obj, expectedJson);
+   }
+
+   private static void Roundtrip_serialize_types_with_struct_properties_using_non_generic_factory(
+      bool skipValueObjectsWithJsonConverterAttribute,
+      object obj,
+      string expectedJson)
+   {
+      var options = new JsonSerializerOptions { Converters = { new ValueObjectJsonConverterFactory(skipValueObjectsWithJsonConverterAttribute) } };
 
       var json = JsonSerializer.Serialize(obj, options);
       json.Should().Be(expectedJson);

test/Thinktecture.Runtime.Extensions.Newtonsoft.Json.Tests/Json/ValueObjectNewtonsoftJsonConverterTests/RoundTrip.cs

@@ -0,0 +1,62 @@
+using System.Collections.Generic;
+using Newtonsoft.Json;
+using Thinktecture.Json;
+using Thinktecture.Runtime.Tests.TestEnums;
+using Thinktecture.Runtime.Tests.TestValueObjects;
+
+namespace Thinktecture.Runtime.Tests.Json.ValueObjectNewtonsoftJsonConverterTests;
+
+public class RoundTrip : JsonTestsBase
+{
+   [Fact]
+   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 }
+      };
+
+      var options = new JsonSerializerSettings { Converters = { new ValueObjectNewtonsoftJsonConverter() } };
+
+      var json = JsonConvert.SerializeObject(dictionary, options);
+      var deserializedDictionary = JsonConvert.DeserializeObject<Dictionary<TestSmartEnum_Class_StringBased, int>>(json, options);
+
+      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 JsonSerializerSettings { Converters = { new ValueObjectNewtonsoftJsonConverter() } };
+
+      var json = JsonConvert.SerializeObject(obj, options);
+      json.Should().Be(expectedJson);
+
+      var deserializedObj = JsonConvert.DeserializeObject(json, obj.GetType(), options);
+      obj.Should().BeEquivalentTo(deserializedObj);
+   }
+
+   private struct TestStruct<T>
+   {
+      public T Prop { get; set; }
+
+      public TestStruct(T prop)
+      {
+         Prop = prop;
+      }
+   }
+}