Was ist der kürzeste Weg zu init-string-array mit einem leeren String?

Umgang mit mehreren Dimensionen

Musste ich arbeiten mit einem Bündel von string-arrays, das musste sein, initialisiert zu leerer, einige multi-dimensional. Das war ein bisschen Schmerz, so habe ich die folgenden, die Sie nützlich finden können:

public static class StringArrayExtensions
{
    public static string[] InitializeWithEmptyStrings(this string[] source)
    {
        //the jitter will hoist source.Length out of the loop automatically here
        for(int i = 0; i < source.Length; i++)
            source[i] = string.Empty;

        return source;          
    }

    public static string[,] InitializeWithEmptyStrings(this string[,] source)
    {
        var len0 = source.GetLength(0);
        var len1 = source.GetLength(1);
        for (int i = 0; i < len0; i++)
            for (int j = 0; j < len1; j++)
                source[i,j] = string.Empty;

        return source;
    }
}

Dann können Sie etwas tun:

class Foo
{
    public string[,] Data = new string[2,2].InitializeWithEmptyStrings();
}

Update - Eine Methode zum verarbeiten der beliebigen Abmessungen

Dachte ich, es wäre Spaß zu versuchen und zu verallgemeinern dies zu kombinieren, erstellen Sie das array, und initialisieren Sie es, mit einem Allgemeinen Zweck-Methode. Es ist nicht so schnell wie die oben genannten, aber es behandelt eine beliebige Anzahl von Dimensionen:

public static class ArrayFactory
{
    public static TArrayType CreateArrayInitializedWithEmptyStrings<TArrayType>(
        params int[] dimensionLengths) where TArrayType : class
    {
        var dimensions = dimensionLengths.Select(l => Enumerable.Range(0, l));
        var array = Array.CreateInstance(typeof(string), dimensionLengths);
        foreach (var indices in CartesianProduct(dimensions))
            array.SetValue(string.Empty, indices.ToArray());

        return (array as TArrayType);
    }

    private static IEnumerable<IEnumerable<T>> CartesianProduct<T>(
    IEnumerable<IEnumerable<T>> dimensions)
    {
        return dimensions.Aggregate(
            (IEnumerable<IEnumerable<T>>)new T[][] { new T[0] },
            (acc, input) =>
                from prevDimension in acc
                from item in input
                select prevDimension.Concat(new T[] { item }));
    }
}

Diese Methode erfordert die gewünschte array als generische parameter verwenden, etwa so:

//this would create a string[2,3,4,2] initialized with empty strings
ArrayFactory.CreateArrayInitializedWithEmptyStrings<string[,,,]>(2,3,4,2);

Requisiten zu Ian Griffiths für seine Artikel-Serie was war die Quelle der verallgemeinerten CartesianProduct Methode.

Update 2

Hier ist eine verfeinerte version des kartesischen Produkts, das verwendet Rekursion, um die index-Kombinationen:

public static class ArrayFactory
{
    public static TArrayType CreateArrayInitializedWithEmptyStrings<TArrayType>(
            params int[] dimensionLengths) where TArrayType : class
    {
        var array = Array.CreateInstance(typeof(string), dimensionLengths);
        foreach (var indices in CartesianProduct(dimensionLengths))
            array.SetValue(string.Empty, indices.ToArray());

        return (array as TArrayType);
    }

    private static IEnumerable<IEnumerable<int>> CartesianProduct(params int[] dimensions)
    {
        return CartesianProductImpl(Enumerable.Empty<int>(), dimensions);

        IEnumerable<IEnumerable<int>> CartesianProductImpl(
            IEnumerable<int> leftIndices, params int[] dims)
        {
            if (dims.Length == 0)
            {
                yield return leftIndices;
                yield break;
            }

            for (int i = 0; i < dims[0]; i++)
                foreach (var elem in CartesianProductImpl(leftIndices.Concat(new[] { i }),
                         dims.Skip(1).ToArray()))
                    yield return elem;
        }
    }
}