C＃通用铸造异常

Question

I have run into an odd casting issue while using generics. The following code will throw an InvalidCastException even though clearly an int can be cast to a double . Can anyone explain this behaviour and how to bypass it?

public class TestClass<T>
{
    public T Cast(object o)
    {
        return (T)o;
    }
}

public void Main()
{
    TestClass<double> w = new TestClass<double>();
    double x = w.Cast(10);
}

Since I am in .net 4.0 land anyway I have changed it to use 'dynamic' instead of 'object' and everything works as expected. Appreciate all the spot-on and quick replies.

Answer 1

But an object can't be cast to a double . The o parameter takes an object , not an int .

For example, the following code fails with an InvalidCastException :

 object o = 1000;
 double x = (double)o;

Answer 2

You can use TypeConverter to convert variables

        public class TestClass<T>
        {
            public T Cast(object o)
            {
                TypeConverter converter = TypeDescriptor.GetConverter(o);
                if (converter.CanConvertTo(typeof(T)))
                {
                   var result = converter.ConvertTo(o, typeof(T));
                   return (T)result;
                }

                throw new InvalidCastException(
                      string.Format("Cannot convert from {0} to {1}", o.GetType().Name, typeof(T).Name));
            }
        }

Answer 3

The parameter 'o' in Cast is boxed. You can't cast a boxed int to an unboxed double, apparently. See here .

If you'd known it was an int inside the Cast function you could do:

return (double)((int)o);

I don't know about the case of an unknown type. Checking.

EDIT: change T to double

Answer 4

This would work

        object y = 10;
        Double v = (int) y;

this will not

        object y = 10;
        Double v = y;

because it has to be casted explicitly.

Answer 5

You could bypass it by doing:

public class TestClass<T>
{
    public T Cast<T2>(T2 o)
    {
        return (T)o;
    }
}

Which should hopefully (no chance to test here) infer that you're using an int and allow the case. Although it doesn't prevent you putting other things that can't be cast properly in.

Answer 6

 public T Cast(object o)
 {
     return (T)Convert.ChangeType(o, typeof (T));

 }

I am not sure why though.

Answer 7

I'm guessing it's because an int can't be casted to a double, but there is an explicit conversion to a double. Which has to be defined on a type. As your Cast object doesn't know whether a given type will have this conversion it tries a basic cast and fails.