Question

I have method that transforms some input value by the user passing it a Func delegate wich returns the new value (very over simplified for what I am trying to achieve)

    public L Coerce<L>(string value, Func<string, L> coercer)
    {
        return coercer(value);
    }

    Coerce<int>("123", v => int.Parse(v));

This is fine however I also want to be able to write methods that override the behaviour for a specific type eg…

    public int Coerce<int>(string value)
    {
        return Coerce<int>(value, v => int.Parse(v));
    }

So basically calling

    Coerce<int>("123"); // equivalent Coerce<int>("123", v => int.Parse(v));

will save me having to re-write the int.Parse for every Coerce. Of course this should then extend to handle

    public decimal Coerce<decimal>(string value)
    {
        return Coerce<decimal>(value, v => int.Parse(v));
    }

Etc etc.

Can this be done neatly?

James

Answer 1

Well, if you really don’t want to do

Convert.ToInt32(value)

Then this will do what you are asking:

public T Coerce<T>(string value) where T : IConvertible
{
    return (T)(((IConvertible)value).ToType(typeof(T),
       CultureInfo.InvariantCulture));
}

Hence:

int x = Coerce<int>("123");

or

byte b = Coerce<byte>("123");

This will give you a compile-time error if you try to coerce to a non-convertible type, for example:

var x = Coerce<MyClass>("123"); //compile-time error

In which case you force the caller to use your Coerce(string value, Func<string,T> coercer) overload.