Generic explicit cast failure C#

Question

I've some issues with the following piece of code. I would like to explicit a string to an object, this is working perfectly fine, however, if this object is part of a generic class, this is failing with the following error exception: "Unable to cast object of type 'System.String' to type 'test.B'". Even though I've overloaded the the method.

using System;
using System.Collections.Generic;

namespace test {
    class Program {
        static void Main(string [] args) {
            // These two cast perfectly fine.
            B x = (B) "abc";
            C y = (C) "def";

            A <B> a = new A<B>();
            a.b();
            A <C> b = new A<C>();
            b.b();
        }
    }

    class A<T> {
        public List <T> a = new List<T>();

        public void b() {
            // Unable to cast object of type 'System.String' to type 'test.B'
            this.a.Add ((T) (object) "abc"); 
            this.a.Add ((T) (object) "def");
            this.a.Add ((T) (object) "ghi");
        }
    }

    class B {
        public string b;

        public static explicit operator B(string a) {
            B x = new B();
            x.b = a;
            return x;
        }
    }

    class C {
        public string c;

        public static explicit operator C(string a) {
            C x = new C();
            x.c = a;
            return x;
        }
    }
}

It would be awesome if somone could explain to me why this isn't casting properly.

Thanks

Marc Gravell · Accepted Answer · 2012-08-13T12:39:56.183

Conversion operators only apply when the type is known statically; after all, generic methods need to use the exact same IL for every T - so it can't call your operator in some cases, and a type-check in others.

Additionally, because you've explicitly cast to object, it will never be used; a cast from object is always a simple unbox or type check.

An evil fix would be (and I don't like this):

        this.a.Add((T)(dynamic)"abc");
        this.a.Add((T)(dynamic)"def");
        this.a.Add((T)(dynamic)"ghi");

which defers the resolution to runtime. It works, but I would need to wash my eyes after that. More generally, though: operators and generics do not play nicely - so: try not to use that combination in your API. I really wouldn't use the above, personally!

Thank you for you fast reply on my question, I appreciate it. I will attemp to find a different approach as after some research on the dynamic type, I agree with you that it isn't the best approach, at all. Thanks again. — Doren Roosje, Aug 13 '12 at 12:30

score 2 · Answer 2 · answered Aug 13 '12 at 12:20

2

Compiler has no knowledge at compile time if generic parameter has explicit cast you are using.

You can introduce interface though, and put constrain on generic parameter

answered Aug 13 '12 at 12:20

vittore

17,449
6
44
82

1

you can't put conversion operators on interfaces, though – Marc Gravell Aug 13 '12 at 12:27
@Marc you can wrap conversion in a method – vittore Aug 13 '12 at 12:37
1

for "convert to" methods, maybe; "convert from" is trickier (which is what is in the question) - you'd need to create an instance of the type to call the method which creates instances of the type - a but yucky – Marc Gravell Aug 13 '12 at 12:38
1

well, there is definitly no way to specify constructor other than parameterless in the generic parameter constrain, but combination of `where T: IMyInter,new()` constrains will do the trick. – vittore Aug 13 '12 at 13:41

score 2 · Answer 3 · answered Aug 13 '12 at 12:42

You inserted the (object) cast to get the compiler to stop telling you that you were doing it wrong. That worked, the compiler can no longer complain because that stopped it from being able to check types. And a cast from object to T might actually work, as small as the odds might be.

What you however didn't count on is that explicit conversion operators are a C# language feature. Only the compiler knows what method to execute when such a cast is applied. It is not a CLR feature, the runtime does not go hunting and gathering to try to find an applicable method to make the conversion. The C# compiler is otherwise powerless to use any of the operators you provided at compile time, it doesn't know the type of T.

Trouble is, the compiler is no longer around to help when the cast executes. Kaboom.

Having generic types applied at runtime instead of compile time is a .NET feature, the generic term is "reified generics". As opposed to "type erasure", the way generics are implemented in Java and C++. The trouble with type erasure is that all info about the generic type arguments are lost after code is compiled, a generic type can't be used by another language and Reflection doesn't work. The trouble with reified generics is that operations that cannot be universally applied to any type cannot be used. Like operator+(). And like this cast.

score 1 · Answer 4 · answered Aug 13 '12 at 12:19

1

Its because T for A<T> does not know about the explicit cast operators for B or C.

answered Aug 13 '12 at 12:19

Daniel A. White

187,200
47
362
445

Generic explicit cast failure C#

4 Answers4

Linked