Converting a List<> to an Array - I get "Attempted to access an element as a type incompatible with the array."

I'm trying to walk through a bunch of items, each item has an array of List<> objects that I want to convert to an array of arrays.. Here's the code to do that:

foreach (IngredientNode i in _snapshot._ingredientMap.Values)
{
   for (int c = 0; c < NUM_TAGS; c++)
   {
      if (i.RecipesByTag[c] == null) continue;
      i.RecipesByTag[c] = i.RecipesByTag[c].ToArray<RecipeN开发者_如何学Code>();
   } <--- EXCEPTION
}

RecipesByTag has a static type of IEnumerable<RecipeNode>[]. However, its dynamic type is List<RecipeNode>[]. I want to go through each one of those and convert the dynamic type of RecopeNode[]. Under the debugger, this works and i.RecipesByTag gets converted. However, the last curly brace then throws the exception:

Attempted to access an element as a type incompatible with the array.

I have a feeling there's some sort of stack corruption going on. Can someone explain what's happening at a technical level here? Thanks!

Mike

You shouldn't have to specify the type argument for the ToArray method, it should be inferred from it's usage, if you are using strongly typed collections. This is a generic type casting problem. You are trying to put elements in an array of some incompatible type.

Your problem should boil to this (these arrays are covariant):

object[] obj = new string[1];
obj[0] = 5; // compiles fine, yields runtime error

Now, the same thing, with different types (these arrays are also covariant):

IEnumerable<int>[] x = new List<int>[1];
x[0] = new int[1]; // compiles fine, yields runtime error

It should be obvious why the type system doesn't like this. Basically, you look at it as if it was an array of IEnumerable<int> but it's actually an array of List<int>. You can not put an unrelated type array of int, into that array.

I believe Eric Lippert explains this very well on his blog.

Okay I think I figured out what's going on.. I have an array of Enumerables. At first, this was an array of pointers to list objects. I instead made this an array of other arrays, in other words I converted my array into a multidimentional array. Since a multidimentional array is consecutive in memory (as opposed to an array of pointers to other arrays), doing this completely corrupted the array in memory. At least that's my theory.

What I did is completely recreate i.RecipesByTag from scratch. Something like this:

List<RecipeNode[]> temp = new List<RecipeNode[]>();

for (int c = 0; c < NUM_TAGS; c++)
{
   RecipeNode[] nodes = (i.RecipesByTag[c] == null) ? null : i.RecipesByTag[c].ToArray<RecipeNode>();
   temp.Add(nodes);
}

i.RecipesByTag = temp.ToArray();

This works perfectly.