Exception for calling ToList() after conversion from uint[] to int[] in C#

Question

I get an exception System.ArrayTypeMismatchException: Source array type cannot be assigned to destination array type for this code snippet:

var uints = GetArray();
if (uints is int[])
{
    var list = ((int[])uints).ToList(); // fails when call ToList()
}

private Array GetArray()
{
    var result = new uint[] { uint.MaxValue, 2, 3, 4, 5 };
    return result;
}

Then I resort to Jon's answer in Why does "int[] is uint[] == true" in C#, it told me that because of GetArray() returns an Array, the conversion was postponed in runtime, and CLR allows this kind of int[] to uint[](vice versa) cast. And it actually works fine if I check values after conversion:

foreach (var i in ((int[])units))
{
    System.Console.WriteLine(i.GetType());
    System.Console.WriteLine(i);
}

I would get:

System.Int32
-1
System.Int32
2
//skipped...

However I kind of get confused why it would fail when calling ToList(), as this code below will work fine?

internal class Animal
{
}

internal class Cat : Animal
{
}

var cats = new Cat[] { new Cat(), new Cat() };
List<Animal> animals = ((Animal[])cats).ToList(); //no exception

Your example for code that works doesn't seem the same as your issue. Cat is an Animal, int is not a uint — o_weisman, Nov 15 '16 at 07:28
Sorry, I was trying the example in LINQPad with optimizations turned on and it incorrectly reported which line of code that failed. — Lasse V. Karlsen, Nov 15 '16 at 07:31
As I expected cast from `uint[]` to `int[]` is NOP check this: `int[] x = ((int[])uints); Console.WriteLine(x.GetType());` it prints `System.UInt32[]` LOL — csharpfolk, Nov 15 '16 at 07:59

Abion47 · Answer 1 · 2016-11-15T07:45:18.963

8

You are trying to cast the array to int[] when it is a uint[]. That by itself is fine, since both int[] and uint[] are of type Array, and casting an Array object of type uint[] as an int[] (or vice versa) is allowed (for some reason).

The problem comes when you try to then convert it to a List. The method is trying to create a List of type int because that's the type you specified, but that's not what the type of the array actually is.

edited Nov 15 '16 at 07:45

answered Nov 15 '16 at 07:29

Abion47

22,211
4
65
88

Sorry, I was trying the example in LINQPad with optimizations turned on and it incorrectly reported which line of code that failed. – Lasse V. Karlsen Nov 15 '16 at 07:32

csharpfolk · Accepted Answer · 2016-11-15T09:55:43.763

What is happening here? Let's start with foreach loop, C# compiler optimizes them heavily especially when you use them with arrays - they are basically changes to normal for(int i = 0; i < length; i++) { } - so the example with

foreach (var i in ((int[])units))
{
    System.Console.WriteLine(i.GetType());
    System.Console.WriteLine(i);
}

cannot be trusted, BTW foreach can also perform cast on element type it is better to try generic Array.GetValue method:

int[] x = ((int[])uints);
Console.WriteLine(x.GetValue(0).GetType()); // System.UInt32

Console.WriteLine(x[0].GetType()); // System.Int32

So even access x[0] can return already casted value but Array.GetValue returned what was already there an uint.

Let's do another experiment:

Console.WriteLine(x.GetType()); // System.UInt32[]

Console.WriteLine(uints.GetType()); // System.UInt32[]

Console.WriteLine(Object.ReferenceEquals(x, uints)); // True

This assures us that cast in var x = (int[])uints is a NOP - no operation, it does nothing at all. Especially 3th line show us the we get exactly the same instance.

Now inside List constructor we have lines

_items = new T[count];
c.CopyTo(_items, 0);

that actually throw Array mismatch exception.

But why this exception wasn't thrown earlier e.g. when GetEnumerator() is called I don't know myself, I expected exception to be thrown on lines

x.GetEnumerator()

because types IEnumerable<int> and IEnumerable<uint> are not compatible but none was - maybe because .NET returns here System.Array+SZArrayEnumerator that is the same for every value type array.

EDIT: (After example with Cat) Array covariance in C# assures us that any array of reference types can be assigned to object[] and that array of type Subclass[] can be assigned to BaseClass[]. The case with value types is different since they can have different sizes and/or conversion behaviours (uint vs int).

ToList uses internally Array.Copy call, when we look at Array.Copy implementation in CRL: https://github.com/dotnet/coreclr/blob/32f0f9721afb584b4a14d69135bea7ddc129f755/src/classlibnative/bcltype/arraynative.cpp#L328 we see that array can be copied only if value types have compatible singess which is checked by another util function https://github.com/dotnet/coreclr/blob/32f0f9721afb584b4a14d69135bea7ddc129f755/src/vm/invokeutil.h#L196

The other question is why it was implemented this way...

I tried `Array cats = new Cat[] { new Cat(), new Cat() };` `var animals = (Animal[])cats;` `System.Console.WriteLine(cats.GetType()); // Cat[]` `System.Console.WriteLine(animals.GetType()); // Cat[]` `System.Console.WriteLine(Object.ReferenceEquals(cats, animals)); // True` Since `IEnumerable` and `IEnumerable` are not compatible, animals.ToList() would also fail? — Kung Pao Chicken, Nov 15 '16 at 08:40
@KungPaoChicken `int` and `uint` types are not compatible but `Cat` and `Animal` are (both are references with child parent relation), this is long known issue with array variance in c#: http://stackoverflow.com/questions/17619139/covariance-and-contravariance-with-c-sharp-arrays (basically every array of reference types is convertible to `object[]`). Since .NET array implementation always returns `System.Array+SZArrayEnumerator` and since `IEnumerable` (see `out` before `T`) is covariant it will works without any exceptions. I guess my example with `IEnumerable` was unfortunate — csharpfolk, Nov 15 '16 at 09:37

Exception for calling ToList() after conversion from uint[] to int[] in C#

2 Answers2

Linked