Updated obsolete types for smoother transition

PawelGerr · PawelGerr · commit 652705815d3f · 2025-04-22T12:21:12.000+02:00
diff --git a/docs b/docs
@@ -1 +1 @@
-Subproject commit 40fcf07e00a4097fbe6cec8d3abaeabf89d49ff1
+Subproject commit 54142987fb95d8fba890acee6270a86265ad5ad9
diff --git a/samples/Thinktecture.Runtime.Extensions.Samples/Unions/TextOrNumberSerializable.cs b/samples/Thinktecture.Runtime.Extensions.Samples/Unions/TextOrNumberSerializable.cs
@@ -10,7 +10,7 @@ namespace Thinktecture.Unions;
                     SwitchMethods = SwitchMapMethodsGeneration.DefaultWithPartialOverloads,
                     MapMethods = SwitchMapMethodsGeneration.DefaultWithPartialOverloads)]
 [ObjectFactory<string>(UseForSerialization = SerializationFrameworks.All)]
-[JsonConverter(typeof(ThinktectureJsonConverterFactory<TextOrNumberSerializable, string, ValidationError>))]
+[JsonConverter(typeof(ThinktectureJsonConverterFactory))] // Optional, ThinktectureJsonConverterFactory can be registered with JsonSerializerOptions
 public partial class TextOrNumberSerializable :
    IObjectFactory<TextOrNumberSerializable, string, ValidationError>, // For deserialization
    IConvertible<string>,                                        // For serialization
diff --git a/src/Thinktecture.Runtime.Extensions.AspNetCore/AspNetCore/ModelBinding/ThinktectureModelBinderProvider.cs b/src/Thinktecture.Runtime.Extensions.AspNetCore/AspNetCore/ModelBinding/ThinktectureModelBinderProvider.cs
@@ -36,7 +36,6 @@ public ValueObjectModelBinderProvider(
 /// <summary>
 /// Provider for creation of model binders for Smart Enums and for Value Objects with a key member.
 /// </summary>
-[ThinktectureRuntimeExtensionInternal]
 public class ThinktectureModelBinderProvider : IModelBinderProvider
 {
    private readonly bool _skipBindingFromBody;
diff --git a/src/Thinktecture.Runtime.Extensions.AspNetCore/AspNetCore/ModelBinding/TrimmingSmartEnumModelBinder.cs b/src/Thinktecture.Runtime.Extensions.AspNetCore/AspNetCore/ModelBinding/TrimmingSmartEnumModelBinder.cs
@@ -5,7 +5,7 @@ namespace Thinktecture.AspNetCore.ModelBinding;
 /// </summary>
 /// <typeparam name="T">Type of the value object.</typeparam>
 /// <typeparam name="TValidationError">Type of the validation error.</typeparam>
-[Obsolete("Use 'mvcOptions.AddThinktectureModelBinding()' instead")]
+[Obsolete("Use 'ThinktectureModelBinderProvider' instead")]
 public sealed class TrimmingSmartEnumModelBinder<T, TValidationError> : ThinktectureModelBinderBase<T, string, TValidationError>
    where T : IObjectFactory<T, string, TValidationError>
    where TValidationError : class, IValidationError<TValidationError>;
diff --git a/src/Thinktecture.Runtime.Extensions.AspNetCore/AspNetCore/ModelBinding/ValueObjectModelBinder.cs b/src/Thinktecture.Runtime.Extensions.AspNetCore/AspNetCore/ModelBinding/ValueObjectModelBinder.cs
@@ -6,7 +6,7 @@ namespace Thinktecture.AspNetCore.ModelBinding;
 /// <typeparam name="T">Type of the value object.</typeparam>
 /// <typeparam name="TKey">Type of the key member.</typeparam>
 /// <typeparam name="TValidationError">Type of the validation error.</typeparam>
-[Obsolete("Use 'mvcOptions.AddThinktectureModelBinding()' instead")]
+[Obsolete("Use 'ThinktectureModelBinderProvider' instead")]
 public sealed class ValueObjectModelBinder<T, TKey, TValidationError> : ThinktectureModelBinderBase<T, TKey, TValidationError>
    where T : IObjectFactory<T, TKey, TValidationError>
    where TKey : notnull
diff --git a/src/Thinktecture.Runtime.Extensions.EntityFrameworkCore.Sources/EntityFrameworkCore/Storage/ValueConversion/ThinktectureValueConverterFactory.cs b/src/Thinktecture.Runtime.Extensions.EntityFrameworkCore.Sources/EntityFrameworkCore/Storage/ValueConversion/ThinktectureValueConverterFactory.cs
@@ -7,7 +7,7 @@ namespace Thinktecture.EntityFrameworkCore.Storage.ValueConversion;
 /// <summary>
 /// Value converter for Smart Enums and for Value Objects with a key member.
 /// </summary>
-[Obsolete("Use 'ThinktectureValueConverterFactory' instead.")]
+[Obsolete("Use 'AddThinktectureValueConverters()' or 'UseThinktectureValueConverters()' with corresponding builder instead.")]
 public sealed class ValueObjectValueConverterFactory : ThinktectureValueConverterFactory;
 
 /// <summary>
diff --git a/src/Thinktecture.Runtime.Extensions.Json/Text/Json/Serialization/ThinktectureJsonConverterFactory.cs b/src/Thinktecture.Runtime.Extensions.Json/Text/Json/Serialization/ThinktectureJsonConverterFactory.cs
@@ -137,15 +137,26 @@ public override bool CanConvert(Type typeToConvert)
       if (type is null)
          return false;
 
-      return !_skipObjectsWithJsonConverterAttribute || type.GetCustomAttribute<JsonConverterAttribute>() is null;
+      if (!_skipObjectsWithJsonConverterAttribute)
+         return true;
+
+      var jsonConverterAttribute = type.GetCustomAttribute<JsonConverterAttribute>();
+
+      if (jsonConverterAttribute is null)
+         return true;
+
+      if (jsonConverterAttribute.ConverterType == typeof(ThinktectureJsonConverterFactory))
+         return true;
+
+      return false;
    }
 
    private static Type? GetObjectType(Type typeToConvert)
    {
       // typeToConvert could be derived type (like nested Smart Enum)
       var metadata = MetadataLookup.Find(typeToConvert);
 
-      if (metadata is not null)
+      if (metadata is Metadata.Keyed)
          return metadata.Type;
 
       if (typeToConvert.GetCustomAttributes<ObjectFactoryAttribute>().Any(a => a.UseForSerialization.HasFlag(SerializationFrameworks.SystemTextJson)))
diff --git a/src/Thinktecture.Runtime.Extensions.MessagePack/ThinktectureMessageFormatterResolver.cs b/src/Thinktecture.Runtime.Extensions.MessagePack/ThinktectureMessageFormatterResolver.cs
@@ -97,7 +97,9 @@ static Cache()
             return;
          }
 
-         var validationErrorType = metadata?.ValidationErrorType ?? type.GetCustomAttribute<ValidationErrorAttribute>()?.Type ?? typeof(ValidationError);
+         var validationErrorType = metadata?.ValidationErrorType
+                                   ?? type.GetCustomAttribute<ValidationErrorAttribute>()?.Type
+                                   ?? typeof(ValidationError);
 
          var formatterTypeDefinition = type.IsClass
                                           ? typeof(ThinktectureMessagePackFormatter<,,>)
diff --git a/src/Thinktecture.Runtime.Extensions.Newtonsoft.Json/Json/ThinktectureNewtonsoftJsonConverter.cs b/src/Thinktecture.Runtime.Extensions.Newtonsoft.Json/Json/ThinktectureNewtonsoftJsonConverter.cs
@@ -12,9 +12,7 @@ namespace Thinktecture.Json;
 public sealed class ValueObjectNewtonsoftJsonConverter<T, TKey, TValidationError> : ThinktectureNewtonsoftJsonConverter<T, TKey, TValidationError>
    where T : IObjectFactory<T, TKey, TValidationError>, IConvertible<TKey>
    where TKey : notnull
-   where TValidationError : class, IValidationError<TValidationError>
-{
-}
+   where TValidationError : class, IValidationError<TValidationError>;
 
 /// <summary>
 /// <see cref="JsonConverter"/> for Value Objects.
diff --git a/src/Thinktecture.Runtime.Extensions.Newtonsoft.Json/Json/ThinktectureNewtonsoftJsonConverterFactory.cs b/src/Thinktecture.Runtime.Extensions.Newtonsoft.Json/Json/ThinktectureNewtonsoftJsonConverterFactory.cs
@@ -14,17 +14,69 @@ public sealed class ValueObjectNewtonsoftJsonConverter : ThinktectureNewtonsoftJ
 /// <summary>
 /// Non-generic converter for Value Objects.
 /// </summary>
-[ThinktectureRuntimeExtensionInternal]
 public class ThinktectureNewtonsoftJsonConverterFactory : JsonConverter
 {
    private static readonly ConcurrentDictionary<Type, JsonConverter> _cache = new();
 
+   private readonly bool _skipObjectsWithJsonConverterAttribute;
+
+   /// <summary>
+   /// Initializes new instance of <see cref="ThinktectureNewtonsoftJsonConverterFactory"/>.
+   /// </summary>
+   public ThinktectureNewtonsoftJsonConverterFactory()
+      : this(true)
+   {
+   }
+
+   /// <summary>
+   /// Initializes new instance of <see cref="ThinktectureNewtonsoftJsonConverterFactory"/>.
+   /// </summary>
+   /// <param name="skipObjectsWithJsonConverterAttribute">
+   /// Indication whether to skip value objects with <see cref="JsonConverterAttribute"/>.
+   /// </param>
+   public ThinktectureNewtonsoftJsonConverterFactory(
+      bool skipObjectsWithJsonConverterAttribute)
+   {
+      _skipObjectsWithJsonConverterAttribute = skipObjectsWithJsonConverterAttribute;
+   }
+
    /// <inheritdoc />
    public override bool CanConvert(Type objectType)
    {
-      return _cache.ContainsKey(objectType)
-             || MetadataLookup.Find(objectType) is not null
-             || objectType.GetCustomAttributes<ObjectFactoryAttribute>().Any(a => a.UseForSerialization.HasFlag(SerializationFrameworks.NewtonsoftJson));
+      if (_cache.ContainsKey(objectType))
+         return true;
+
+      var type = GetObjectType(objectType);
+
+      if (type is null)
+         return false;
+
+      if (!_skipObjectsWithJsonConverterAttribute)
+         return true;
+
+      var jsonConverterAttribute = type.GetCustomAttribute<JsonConverterAttribute>();
+
+      if (jsonConverterAttribute is null)
+         return true;
+
+      if (jsonConverterAttribute.ConverterType == typeof(ThinktectureNewtonsoftJsonConverterFactory))
+         return true;
+
+      return false;
+   }
+
+   private static Type? GetObjectType(Type objectType)
+   {
+      // objectType could be derived type (like nested Smart Enum)
+      var metadata = MetadataLookup.Find(objectType);
+
+      if (metadata is Metadata.Keyed)
+         return metadata.Type;
+
+      if (objectType.GetCustomAttributes<ObjectFactoryAttribute>().Any(a => a.UseForSerialization.HasFlag(SerializationFrameworks.NewtonsoftJson)))
+         return objectType;
+
+      return null;
    }
 
    /// <inheritdoc />
diff --git a/src/Thinktecture.Runtime.Extensions.SourceGenerator/Extensions/TypeSymbolExtensions.cs b/src/Thinktecture.Runtime.Extensions.SourceGenerator/Extensions/TypeSymbolExtensions.cs
@@ -138,15 +138,15 @@ public static bool IsMemberEqualityComparerAttribute(this ITypeSymbol? attribute
       if (attributeType is null || attributeType.TypeKind == TypeKind.Error)
          return false;
 
-      return attributeType is { Name: "MemberEqualityComparerAttribute", ContainingNamespace: { Name: "Thinktecture", ContainingNamespace.IsGlobalNamespace: true } };
+      return attributeType is { Name: "MemberEqualityComparerAttribute" or "ValueObjectMemberEqualityComparerAttribute", ContainingNamespace: { Name: "Thinktecture", ContainingNamespace.IsGlobalNamespace: true } };
    }
 
    public static bool IsMemberIgnoreAttribute(this ITypeSymbol? attributeType)
    {
       if (attributeType is null || attributeType.TypeKind == TypeKind.Error)
          return false;
 
-      return attributeType is { Name: "IgnoreMemberAttribute", ContainingNamespace: { Name: "Thinktecture", ContainingNamespace.IsGlobalNamespace: true } };
+      return attributeType is { Name: "IgnoreMemberAttribute" or "ValueObjectMemberIgnoreAttribute", ContainingNamespace: { Name: "Thinktecture", ContainingNamespace.IsGlobalNamespace: true } };
    }
 
    public static bool IsUseDelegateFromConstructorAttribute(this ITypeSymbol? attributeType)
@@ -185,28 +185,33 @@ public static bool IsMessagePackFormatterAttribute(this ITypeSymbol type)
 
    public static bool IsObjectFactoryAttribute(this INamedTypeSymbol type)
    {
-      return type is { Name: "ObjectFactoryAttribute", TypeArguments.Length: 1, ContainingNamespace: { Name: "Thinktecture", ContainingNamespace.IsGlobalNamespace: true } };
+      return type is { Name: "ObjectFactoryAttribute" or "ValueObjectFactoryAttribute", TypeArguments.Length: 1, ContainingNamespace: { Name: "Thinktecture", ContainingNamespace.IsGlobalNamespace: true } };
    }
 
    public static bool IsValidationErrorAttribute(this INamedTypeSymbol type)
    {
-      return type is { Name: "ValidationErrorAttribute", TypeArguments.Length: 1, ContainingNamespace: { Name: "Thinktecture", ContainingNamespace.IsGlobalNamespace: true } };
+      return type is { Name: "ValidationErrorAttribute" or "ValueObjectValidationErrorAttribute", TypeArguments.Length: 1, ContainingNamespace: { Name: "Thinktecture", ContainingNamespace.IsGlobalNamespace: true } };
    }
 
    public static bool IsKeyMemberComparerAttribute(this INamedTypeSymbol? attributeType)
    {
       if (attributeType is null || attributeType.TypeKind == TypeKind.Error)
          return false;
 
-      return attributeType is { Name: "KeyMemberComparerAttribute", TypeArguments.Length: 2, ContainingNamespace: { Name: "Thinktecture", ContainingNamespace.IsGlobalNamespace: true } };
+      return attributeType is { Name: "KeyMemberComparerAttribute" or "ValueObjectKeyMemberComparerAttribute", TypeArguments.Length: 2, ContainingNamespace: { Name: "Thinktecture", ContainingNamespace.IsGlobalNamespace: true } };
    }
 
    public static bool IsKeyMemberEqualityComparerAttribute(this INamedTypeSymbol? attributeType)
    {
       if (attributeType is null || attributeType.TypeKind == TypeKind.Error)
          return false;
 
-      return attributeType is { Name: "KeyMemberEqualityComparerAttribute", TypeArguments.Length: 2, ContainingNamespace: { Name: "Thinktecture", ContainingNamespace.IsGlobalNamespace: true } };
+      return attributeType is
+      {
+         Name: "KeyMemberEqualityComparerAttribute" or "ValueObjectKeyMemberEqualityComparerAttribute",
+         TypeArguments.Length: 2,
+         ContainingNamespace: { Name: "Thinktecture", ContainingNamespace.IsGlobalNamespace: true }
+      };
    }
 
    public static bool IsStructLayoutAttribute(this ITypeSymbol type)
diff --git a/src/Thinktecture.Runtime.Extensions/IObjectFactory.cs b/src/Thinktecture.Runtime.Extensions/IObjectFactory.cs
@@ -1,5 +1,21 @@
 namespace Thinktecture;
 
+/// <summary>
+/// Marker interface.
+/// </summary>
+/// <remarks>
+/// Don't use this interface directly. It will be used by a source generator.
+/// </remarks>
+[Obsolete("Use 'IObjectFactory<TValue>' instead.")]
+public interface IValueObjectFactory<TValue> : IObjectFactory<TValue>
+   where TValue : notnull
+#if NET9_0_OR_GREATER
+               , allows ref struct
+#endif
+// ReSharper disable once RedundantTypeDeclarationBody
+{
+}
+
 /// <summary>
 /// Marker interface.
 /// </summary>
@@ -26,7 +42,7 @@ public interface IObjectFactory<TValue>
 /// Don't use this interface directly. It will be used by a source generator.
 /// </remarks>
 [Obsolete("Use 'IObjectFactory<T, TValue, TValidationError>' instead.")]
-public interface IValueObjectFactory<T, TValue, out TValidationError> : IObjectFactory<TValue>
+public interface IValueObjectFactory<T, TValue, out TValidationError> : IObjectFactory<T, TValue, TValidationError>
    where TValue : notnull
 #if NET9_0_OR_GREATER
                , allows ref struct
diff --git a/src/Thinktecture.Runtime.Extensions/ISmartEnum.cs b/src/Thinktecture.Runtime.Extensions/ISmartEnum.cs
@@ -7,7 +7,7 @@ namespace Thinktecture;
 /// </summary>
 /// <typeparam name="TKey">Type of the key.</typeparam>
 [Obsolete("Use 'ISmartEnum<TKey>' instead.")]
-public interface IEnum<TKey> : IKeyedObject<TKey>
+public interface IEnum<TKey> : ISmartEnum<TKey>
    where TKey : notnull;
 
 /// <summary>
@@ -20,7 +20,7 @@ public interface IEnum<TKey> : IKeyedObject<TKey>
 /// Don't implement this interface directly. It will be implemented by a source generator.
 /// </remarks>
 [Obsolete("Use 'ISmartEnum<TKey, T, TValidationError>' instead.")]
-public interface IEnum<TKey, T, out TValidationError> : ISmartEnum<TKey>, IObjectFactory<T, TKey, TValidationError>
+public interface IEnum<TKey, T, out TValidationError> : ISmartEnum<TKey, T, TValidationError>
    where T : ISmartEnum<TKey>
    where TKey : notnull
    where TValidationError : class, IValidationError<TValidationError>;
diff --git a/src/Thinktecture.Runtime.Extensions/ThinktectureTypeConverter.cs b/src/Thinktecture.Runtime.Extensions/ThinktectureTypeConverter.cs
@@ -13,9 +13,7 @@ namespace Thinktecture;
 public class ValueObjectTypeConverter<T, TKey, TValidationError> : ThinktectureTypeConverter<T, TKey, TValidationError>
    where T : IObjectFactory<T, TKey, TValidationError>, IConvertible<TKey>
    where TKey : notnull
-   where TValidationError : class, IValidationError<TValidationError>
-{
-}
+   where TValidationError : class, IValidationError<TValidationError>;
 
 /// <summary>
 /// Type converter to convert corresponding types to <typeparamref name="TKey"/> and vice versa.
diff --git a/src/Thinktecture.Runtime.Extensions/UnknownSmartEnumIdentifierException.cs b/src/Thinktecture.Runtime.Extensions/UnknownSmartEnumIdentifierException.cs
@@ -3,7 +3,24 @@ namespace Thinktecture;
 /// <summary>
 /// The provided value doesn't match any enumeration item.
 /// </summary>
-public sealed class UnknownSmartEnumIdentifierException : KeyNotFoundException
+[Obsolete("Use 'UnknownSmartEnumIdentifierException' instead.")]
+public sealed class UnknownEnumIdentifierException : UnknownSmartEnumIdentifierException
+{
+   /// <summary>
+   /// Initializes new instance of <see cref="UnknownSmartEnumIdentifierException"/>.
+   /// </summary>
+   /// <param name="enumType">The type of the enumeration.</param>
+   /// <param name="value">Provided value.</param>
+   public UnknownEnumIdentifierException(Type enumType, object value)
+      : base(enumType, value)
+   {
+   }
+}
+
+/// <summary>
+/// The provided value doesn't match any enumeration item.
+/// </summary>
+public class UnknownSmartEnumIdentifierException : KeyNotFoundException
 {
    /// <summary>
    /// Type of the enumeration.
diff --git a/src/Thinktecture.Runtime.Extensions/ValidationErrorAttribute.cs b/src/Thinktecture.Runtime.Extensions/ValidationErrorAttribute.cs
@@ -1,5 +1,14 @@
 namespace Thinktecture;
 
+/// <summary>
+/// Defines custom type to be used as a validation error.
+/// </summary>
+/// <typeparam name="TValidationError">Type of the validation error.</typeparam>
+[Obsolete("Use 'ValidationErrorAttribute<TValidationError>' instead.")]
+[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct, Inherited = false)]
+public sealed class ValueObjectValidationErrorAttribute<TValidationError> : ValidationErrorAttribute<TValidationError>
+   where TValidationError : class, IValidationError<TValidationError>;
+
 /// <summary>
 /// Defines a custom type to be used as a validation error.
 /// </summary>
@@ -24,7 +33,7 @@ private protected ValidationErrorAttribute(Type type)
 /// </summary>
 /// <typeparam name="TValidationError">Type of the validation error.</typeparam>
 [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct, Inherited = false)]
-public sealed class ValidationErrorAttribute<TValidationError> : ValidationErrorAttribute
+public class ValidationErrorAttribute<TValidationError> : ValidationErrorAttribute
    where TValidationError : class, IValidationError<TValidationError>
 {
    /// <summary>
diff --git a/test/Thinktecture.Runtime.Extensions.Tests.Shared/TestAdHocUnions/TextOrNumberSerializable.cs b/test/Thinktecture.Runtime.Extensions.Tests.Shared/TestAdHocUnions/TextOrNumberSerializable.cs
@@ -7,7 +7,7 @@ namespace Thinktecture.Runtime.Tests.TestAdHocUnions;
 
 [Union<string, int>(T1Name = "Text", T2Name = "Number")]
 [ObjectFactory<string>(UseForSerialization = SerializationFrameworks.All)]
-[JsonConverter(typeof(ThinktectureJsonConverterFactory<TextOrNumberSerializable, string, ValidationError>))]
+[JsonConverter(typeof(ThinktectureJsonConverterFactory))]
 public partial class TextOrNumberSerializable :
    IObjectFactory<TextOrNumberSerializable, string, ValidationError>,
    IConvertible<string>,

Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,6 @@ public ValueObjectModelBinderProvider(`
`36`	`36`	`/// <summary>`
`37`	`37`	`/// Provider for creation of model binders for Smart Enums and for Value Objects with a key member.`
`38`	`38`	`/// </summary>`
`39`		`-[ThinktectureRuntimeExtensionInternal]`
`40`	`39`	`public class ThinktectureModelBinderProvider : IModelBinderProvider`
`41`	`40`	`{`
`42`	`41`	`private readonly bool _skipBindingFromBody;`
Original file line number	Diff line number	Diff line change
`@@ -97,7 +97,9 @@ static Cache()`
`97`	`97`	`return;`
`98`	`98`	`}`
`99`	`99`
`100`		`- var validationErrorType = metadata?.ValidationErrorType ?? type.GetCustomAttribute<ValidationErrorAttribute>()?.Type ?? typeof(ValidationError);`
	`100`	`+ var validationErrorType = metadata?.ValidationErrorType`
	`101`	`+ ?? type.GetCustomAttribute<ValidationErrorAttribute>()?.Type`
	`102`	`+ ?? typeof(ValidationError);`
`101`	`103`
`102`	`104`	`var formatterTypeDefinition = type.IsClass`
`103`	`105`	`? typeof(ThinktectureMessagePackFormatter<,,>)`