Question

我试图能够通过锯齿状数组但数组深度不是恒定的。我正在寻找一种干净的方式来遍历数组中的每个对象。现在我有一个简单的开关案例，可以通过将其Rank作为案例的int来处理不同的级别。

但有时阵列深度为2级，有时深度为5级。我想不必为每个深度级别写一个案例。

例如，我有一个名为myObj的对象，有时它是myObj []或myObj [] []或myObj [] [] [] [];

使用foreach或IEnumerator只遍历数组的第一个维度

Answer 1

这是一个遍历锯齿状/多维数组的扩展方法（类似于David B. one's但有yield，null处理和类型转换）：

public static class Extensions
{
    public static IEnumerable<T> Traverse<T>(this Array array)
    {
        foreach (object val in array)
        {
            if (val == null)
                continue; //null means empty sub-array --> skip it
            if (val is Array)
            {
                var subArray = (Array)val;
                foreach (var value in subArray.Traverse<T>())
                    yield return value;
            }
            else
            {
                yield return (T)val;
            }
        }
    }
}

用法示例：

class Program
{
    static void Main(string[] args)
    {
        int[][][] jagged = new int[4][][];

        jagged[0] = new int[2][] { new[] { 0, 1 }, new[] { 2, 3, 4 } };
        jagged[1] = new int[3][] { new[] { 5, 6, 7 }, new[] { 8, 9, 10 }, new[] { 11, 12 } };
        jagged[3] = new int[4][] { new[] { 13, 14 }, null, new[] { 15, }, new[] { 16 } };

        var jaggedElements = jagged.Traverse<int>().ToList();
        // contains:  1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16

       int[, ,] multi = new[, ,] { { { 1, 2 }, { 3, 4 } },
                        { { 4, 5 }, { 6, 7 } }, 
                        { { 8, 9 }, { 10, 11 } } };


       var multiElements = multi.Traverse<int>().ToList();
       // contains:  1,2,3,4,5,6,7,8,9,10,11

    }
}

Answer 2

这应该这样做。。

private static void EnumerateObjects(Array items)
{
    foreach (var item in items)
    {
        if (item is Array)
        {
            EnumerateObjects((Array)item);
        }
        else if (item is MyObject)
        {
            Console.WriteLine(item);
        }
    }
}

Answer 3

这样的东西？

    static void Main(string[] args)
    {
        int[][][] x = new int[][][]
        {
            new int[][]
            {
                new int [] { 1, 2, 3, 4 },
                new int [] { 5, 6 },
                new int [] { 7 }
            },
            new int[][]
            {
                new int [] { 8 },
                new int [] { 9, 10 },
                new int [] { 11, 12, 13, 14 }
            }
        };

        DeepEnumerateArray(x);
        Console.ReadLine();
    }

    static void DeepEnumerateArray(Array x)
    {
        if (x.Length == 0)
            return;

        object first = x.GetValue(0);
        if (first is Array)
        {
            foreach (Array y in x)
                DeepEnumerateArray(y);
        }
        else
        {
            foreach (object z in x)
                Console.WriteLine(z);
        }
    }

Answer 4

你的回答是递归。我觉得这不行。如果您有一个包含子集合的类，它将起作用。

int main()
{
    CheckObj(myObject, 0);
}

void CheckObj(object myObject, int level)
{
    if(!(myObject is myObj[]))
    {
        foreach(myObj[] o in (myObj[][])myObject)
        {
            CheckObj(o, level + 1);
        }
    }
    else
    {
        //do what you need to do with myObj[]
    }
}

遍历n维Jagged数组

4 个答案: