Way to define List<> of two elements string array?

Question

I want to build two-dimentional array of strings where length of one dimention is 2. Similar to this

string[,] array = new string[,]
{
    {"a", "b"},
    {"c", "d"},
    {"e", "f"},
    {"g", "h"}
}

Doing

List<string[]> list = new List<string[]>();

list.Add(new string[2] {"a", "b"});
list.Add(new string[2] {"c", "d"});
list.Add(new string[2] {"e", "f"});
list.Add(new string[2] {"g", "h"});

list.ToArray();

gives me

string[][]

but not

string[,]

array.

Just curious, is there some trick to build dynamically

string[,]

array somehow?

Thanks!

Answer 1

This isn't possible with a List<string[]> as the type string[,] is different to string[]

Answer 2

The only way to do it would be to implement the ToArray() function yourself. You could implement it within your own collection (ie StringTupleCollection). This could work the same as ArrayList (ie internal array increasing in size as needed).

However I'm not sure the advantage of [x,2] over [x][2] (or even List would be significant enough to warrant the effort.

You could also write a StringTupple class as:

public class StringTupple : KeyValuePair { }

Answer 3

Well, you could reasonably easily write an extension method to do it. Something like this (only tested very slightly):

public static T[,] ToRectangularArray<T>(this IEnumerable<T[]> source)
{
    if (!source.Any())
    {
        return new T[0,0];
    }

    int width = source.First().Length;
    if (source.Any(array => array.Length != width))
    {
         throw new ArgumentException("All elements must have the same length");
    }

    T[,] ret = new T[source.Count(), width];
    int row = 0;
    foreach (T[] array in source)
    {
       for (int col=0; col < width; col++)
       {
           ret[row, col] = array[col];
       }
       row++;
    }
    return ret;
}

It's a slight shame that the above code uses T[] as the element type. Due to generic invariance I can't currently make source IEnumerable<IEnumerable<T>> which would be nice. An alternative might be to introduce a new type parameter with a constraint:

public static T[,] ToRectangularArray<T,U>(this IEnumerable<U> source)
    where U : IEnumerable<T>

Somewhat hairy, but it should work. (Obviously the implementation needs some changes too, but the basic principle is the same.)