Reversing a type converter with minimal redundancies

Question

The objective is to implement the reversed version of StringToDoubleConverter but without writing too many redundancies. I love DRY (Don't Repeat Yourself) design principle.

public class StringToDoubleConverter : IValueConverter
{
    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
    {
        return double.TryParse(value as string, out var x) ? x : double.NaN;
    }

    public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
    {
        return value is double x ? x.ToString("f3") : string.Empty;
    }
}

Here are my approaches. Any suggestions or comments are welcome.

Version A: Inheritance

public class DoubleToStringConverter : StringToDoubleConverter, IValueConverter
{
    public new object Convert(object value, Type targetType, object parameter, CultureInfo culture)
    {
        return base.ConvertBack(value, targetType, parameter, culture);
    }
    public new object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
    {
        return base.Convert(value, targetType, parameter, culture);
    }
}

Version B: Composition

public class DoubleToStringConverter : IValueConverter
{
    private static readonly StringToDoubleConverter std = new();

    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
    {
        return std.ConvertBack(value, targetType, parameter, culture);
    }
    public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
    {
        return std.Convert(value, targetType, parameter, culture);
    }
}

Answer 1

Why don't you define an abstract class with the following two methods:

• One which can convert an object to string
• Another which can convert an object to double

public abstract class FromObjectConverter
{
    protected double ToDouble(object value)
        => double.TryParse(value as string, out var x) ? x : double.NaN;

    protected string ToString(object value)
        => value is double x ? x.ToString("f3") : string.Empty;
}

With this class in our hand the two concrete converter classes are just simple wrappers

public sealed class StringToDoubleConverter : FromObjectConverter, IValueConverter
{
    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
        => ToDouble(value);

    public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
        => ToString(value);
}

public sealed class DoubleToStringConverter : FromObjectConverter, IValueConverter
{
    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
        => ToString(value);

    public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
        => ToDouble(value);
}

---

Or if you want to avoid inheritance then define the FromObjectConverter class and its methods as static.