Generic value retriever & comparer for IParsable<T>?

[ronaldbosma]

I've created a generic value retriever and comparer that can handle value types implementing IParsable<T>. See this blog post.

Should we consider adding this to Reqnroll as a new feature, or is it impossible due to backwards compatibility issues since IParsable<T> was introduced in .NET 7?

[Code-Grump]

We currently target .NET Standard 2.0, so this would only be possible if we decided to change our target platforms. Other than this significant complication, I think it is a fantastic proposal.

[ajeckmans]

There is also the thing that we are looking into merging the ArgumentTransformation and ValueReteiever functionality into one code path. I actually have a proposal on how to dot gat which i need to write down still. Although any such thing would be kept parallel to this for some time.

In any case, this could be added as an (official) plugin maybe?

[walshy-1111]

Another option would be to use the TypeConverter class.
Its unfortunately a little bulkier, but I believe it is available in .Net Standard
TypeConverter and its associated attribute are defined in the System.ComponentModel namespace.

I've done this because we have some projects in .Net6, but I much prefer the IParsable<> implementation shown in the blog.

I also created an abstract intermediary of the TypeConverter class to generalise much of the boilerplate away, and then I only need to implement a Parse method for each type I use.

I've included an example below:

[TypeConverter(typeof(ProductTypeConverter)]
public sealed record class Product
{ 
        private readonly string _code;
        private static Regex _pattern = new Regex("");
        public static Product Parse(string? text)
        {
                Guard.IsNotNullOrWhiteSpace(text, nameof(text));
                if(_pattern.Match(text).IsSuccess)
                { 
                         return new Product(text);
                }
                throw new ArgumentException();
        }
        public sealed override string ToString() => this._code;
}

public sealed class ProductTypeConverter : TypeConverter
{
        /// <inheritdoc/>
       public override bool CanConvertFrom(ITypeDescriptorContext? context, Type sourceType)
               => sourceType == typeof(string) || base.CanConvertFrom(context, sourceType);

        /// <inheritdoc/>
        public override bool CanConvertTo(ITypeDescriptorContext? context, Type? destinationType)
                => destinationType == typeof(string) || base.CanConvertTo(context, destinationType);

        /// <inheritdoc/>
       public override object? ConvertFrom(ITypeDescriptorContext? context, CultureInfo? culture, object value)
               => value is string stringValue
                    ? Product.Parse(stringValue)
                   : base.ConvertFrom(context, culture, value);

         /// <inheritdoc/>
        public override object? ConvertTo(ITypeDescriptorContext? context, CultureInfo? culture, object? value, Type destinationType)
               => destinationType == typeof(string) && value != null
                  ? value.ToString()
                  : base.ConvertTo(context, culture, value, destinationType);
}

/// <summary>
/// The fallback value retriever for custom types.
/// Uses their defined <see cref="TypeConverter"/> to convert the string value to the correct type.
/// </summary>
/// <typeparam name="TType"></typeparam>
public sealed class FallbackValueRetriever<TType> : IValueRetriever
{
    /// <inheritdoc/>
    public bool CanRetrieve(KeyValuePair<string, string> keyValuePair, Type targetType, Type propertyType)
    { 
          TypeConverter typeDescriptor = TypeDescriptor.GetConverter(typeof(TType));
          return typeof(TType) == propertyType && typeDescriptor.CanConvertFrom(typeof(string));
    }

    /// <inheritdoc/>
    public object Retrieve(KeyValuePair<string, string> keyValuePair, Type targetType, Type propertyType)
    {
        TypeConverter typeDescriptor = TypeDescriptor.GetConverter(typeof(TType));
        object? response = typeDescriptor.ConvertFromString(keyValuePair.Value);
        Guard.IsNotNull(response, nameof(response));
        return response;
    }
}

The ValueRetriever could be easily changed to be non-generic using a Type as a parameter in the constructor.