Force type setter to accept compatible types

Question

Say there is a class

public class MyClass { public decimal Id { get; set; } }

I need to dynamically assign decimals, ints, bytes etc to the Id using setter method for the Id property, something like this:

var setterMethod = typeof(MyClass).GetMethods(...)...First();
setterMethod.Invoke(myClassInstance, (int)1);

But this doesnt work because of types mismatch (int vs. decimal).

In the same time this works well:

decimal decZero = 0;
int intZero = 0;
byte byteZero = 0;
var sample1 = new MyClass{ Id = decZero };  
var sample2 = new MyClass{ Id = intZero };  
var sample3 = new MyClass{ Id = byteZero };  

what means the C# can implicitly cast numeric types.

How can I dynamically assign ints, decimals, bytes etc to the Id prop using type setter?

Answer 1

(rewrote the answer to handle conversion among numeric types, along with their nullable and/or enumerable variations)

To handle the conversion between built-in numeric types, the Convert.ChangeType(object,Type) method will be your friend. Just make sure the value implements IConvertible interface (primitive .NET types like ints or doubles generally do).

When casting between enumerable and numeric types, Enum.ToObject(Type,object) should be used instead. The value given should match the enumerable underlying type, so to convert a decimal to integer-based int, an extra conversion will be necessary.

If string parsing is required, then Enum.Parse(Type,string) will be necessary for handling enumerable values. For plain numeric types, Convert.ChangeType should suffice, as long as you don't try to parse integer types from strings in decimal point format.

Finally, Convert.ChangeType doesn't work with nullable types, so the underlying type will need to be extracted first. Nullable.GetUnderlyingType(Type) is for just that.

Putting it all together, we can build an extended ChangeType method:

public static object ExtendedChangeType(object value, Type targetType)
{
    if (value == null)
        return null;

    targetType = Nullable.GetUnderlyingType(targetType) ?? targetType;
    if (targetType.IsEnum)
    {
        if (value is string)
        {
            return Enum.Parse(targetType, value as string);
        }
        else
        {
            value = Convert.ChangeType(value, Enum.GetUnderlyingType(targetType));
            return Enum.ToObject(targetType, value);
        }
    }
    else
    {
        return Convert.ChangeType(value, targetType);
    }
}

Then we can use it like this:

PropertyInfo property = typeof(MyClass).GetProperty(nameof(MyClass.Id));
var value = ExtendedChangeType((int)1, valueType);
property.SetValue(myClassInstance, value);

Answer 2

How can I dynamically assign ints, decimals, bytes etc to the Id prop using type setter?

You can try this:

var converted = Convert.ChangeType((int)10, property.PropertyType);
property.SetValue(sample2, converted);

Here it is as a fiddle that dynamically assigns ints, decimals, and bytes to a decimal property.

using System;

public class Program
{
    public static void Main()
    {
        var sample1 = new MyClass{Id = (decimal)0};
        var sample2 = new MyClass{Id = (int)0};
        var sample3 = new MyClass{Id = (byte)0};

        var property = typeof (MyClass).GetProperty(nameof(MyClass.Id));

        property.SetValue(sample1, Convert.ChangeType((decimal)10, property.PropertyType));
        property.SetValue(sample2, Convert.ChangeType((int)10, property.PropertyType));
        property.SetValue(sample3, Convert.ChangeType((byte)10, property.PropertyType));
    }
}

public class MyClass
{
    public decimal Id { get; set; }
}

Answer 3

You simply can't because of covariance and contravariance however in your case is invariance but it is related.

While operator = makes implicit conversion to the desired type, MethodBase.Invoke hopes for different thing.

Debug your code, put a breakpoint at the invocation of the method. See that the method itself has following definition - {Void set_Id(System.Decimal)} which is obvious right? It takes one parameter of type decimal, while compiler can do magic for you allowing to call it implicitly during runtime things are different.

IL instructions showing what happens when you do it with assignment operator

    using System;
    using System.Collections.Generic;

    namespace ConsoleApp1
    {
        class Program
        {
            static void Main(string[] args)
            {
                var testIntance = new Test();
                testIntance.Id = (int)5;
            }
        }

        public class Test { public decimal Id { get; set; } }
    }
    //
    // IL of Main method
    //
    .method private hidebysig static 
        void Main (
            string[] args
        ) cil managed 
    {
        // Method begins at RVA 0x2050
        // Code size 17 (0x11)
        .maxstack 8

        IL_0000: newobj instance void ConsoleApp1.Test::.ctor()
        IL_0005: ldc.i4.5
        IL_0006: newobj instance void [mscorlib]System.Decimal::.ctor(int32) - not so implicit for the compiler 
        IL_000b: callvirt instance void ConsoleApp1.Test::set_Id(valuetype [mscorlib]System.Decimal)
        IL_0010: ret
    } // e

Lets create more interesting case

    namespace ConsoleApp1
    {
        class Program
        {
            static void Main(string[] args)
            {
                var a = 5;
                Test(a);
            }

            static void Test(decimal number) { }
        }
    }

    //
    // IL of the main method
    //
    .method private hidebysig static 
        void Main (
            string[] args
        ) cil managed 
    {
        // Method begins at RVA 0x2050
        // Code size 12 (0xc)
        .maxstack 8

        IL_0000: ldc.i4.5
        IL_0001: call valuetype [mscorlib]System.Decimal [mscorlib]System.Decimal::op_Implicit(int32)
        IL_0006: call void ConsoleApp1.Program::Test(valuetype [mscorlib]System.Decimal)
        IL_000b: ret
    } // end of method Program::Main

Invoke expects type to be compatible in a sense that one can "be in place of the another" (check the covariance and contravariance stuff).

With that being said lets see what what will happen if I put the following code.

public class Test { public IEnumerable<int> Id { get; set; } }

...

var setter = typeof(Test).GetMethods()[1];
setter.Invoke(new Test(), new object[] { new List<int> { 1 } });

Now it passes, because obviously List is IEnumerable and there are no violations during runtime.

So now that you know how it works maybe you can figure it out which case is best for you.