explicit cast operator applied to instance created through reflection

Question

I was suprised when found that the following code throws exception at runtime:

class A
{
    public string Name { get; set; }

    public A()
    {
        Name = "Class A";
    }
}

class B
{
    public string Name { get; set; }

    public B()
    {
        Name = "Class B";
    }

    public static explicit operator A(B source)
    {
        return new A() {Name = source.Name};
    }
}


class Program
{
    static void Main(string[] args)
    {
        // This executes with no error
        var bInstance = new B();
        Console.WriteLine(bInstance.GetType()); // <assemblyname>.B
        var aInstance = (A) bInstance;
        Console.WriteLine(aInstance.Name); // Class B

        // This fails with InvalidCastException
        var bInstanceReflection = Activator.CreateInstance(typeof (B));
        Console.WriteLine(bInstanceReflection.GetType()); // <assemblyname>.B
        var aInstanceReflection = (A) bInstanceReflection;

        Console.WriteLine(aInstanceReflection.Name);
    }
}

Could anyone tell me why? I don't really understand what happened

Jon Skeet · Accepted Answer · 2011-08-02 12:19:57Z

7

You shouldn't be surprised - custom operators don't override anything, they overload - so they're picked at compile time, not execution time.

When we remove implicit typing from the code, it makes it a bit clearer:

object bInstanceReflection = Activator.CreateInstance(typeof (B));
Console.WriteLine(bInstanceReflection.GetType()); // <assemblyname>.B
A aInstanceReflection = (A) bInstanceReflection;

Now it's reasonably clear that in the final line, (A) is just a cast from object which performs the normal reference conversion. No user-defined conversions will be applied at all.

If you're using .NET 4, you can use dynamic typing to get it to work:

// Note the change of type
dynamic bInstanceReflection = Activator.CreateInstance(typeof (B));
Console.WriteLine(bInstanceReflection.GetType()); // <assemblyname>.B
A aInstanceReflection = (A) bInstanceReflection;

Now the conversion is being applied on a dynamic value, which means the choice of what conversion to use is deferred until execution time - at which point it will use your custom operator.

answered Aug 2, 2011 at 12:19

Jon Skeet

1.5m893 gold badges9.3k silver badges9.3k bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

Alex Over a year ago

Thanks Jon, your post is very useful for me!

Marc Gravell · Accepted Answer · 2011-08-02 12:19:09Z

3

You've created a B. And then cast it to an A.

Despite having similar layouts, B has no relationship to A. Static operators are applied by the compiler, but not at runtime via cast. Although the C# syntax is the same, they are very different when dealing with reflection.

This is the normal, expected behaviour.

answered Aug 2, 2011 at 12:19

Marc Gravell

1.1m273 gold badges2.6k silver badges3k bronze badges

1 Comment

Alex Over a year ago

Thanks Marc, it was really new for me. I also found Eric Lippert answer to the similar question stackoverflow.com/questions/2090092/…

Francesco · Accepted Answer · 2011-09-09 15:00:11Z

1

You can simply change this line:

var bInstanceReflection = Activator.CreateInstance(typeof (B));

To:

var bInstanceReflection = (B)Activator.CreateInstance(typeof (B));

So the compiler now knows the type of bInstanceReflection and can call the correct implitic operator.

answered Sep 9, 2011 at 15:00

Francesco

111 bronze badge

Collectives™ on Stack Overflow

explicit cast operator applied to instance created through reflection

3 Answers 3

1 Comment

1 Comment

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

1 Comment

1 Comment

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related