Question

我有List<object>，其中包含字符串甚至其他列表。

List<object> NewArray = new List<object>();

所以基本上这个列表包含一个混合....

作为一个完整性检查，我想将内容打印到控制台。我开始迭代并测试以查看元素是否是列表。如果不是那么它将是一个字符串，可以打印到控制台。如果它是一个列表，我想迭代并将字符串内容打印到控制台，但使用一个标签来缩进它。

到目前为止，我有这个：

    for (int outer = 0; outer < NewArray.Count; outer++)
            {

                var innerList = NewArray[outer];

                if (innerList.GetType().IsGenericType && innerList.GetType().GetGenericTypeDefinition() == typeof(List<>))
                {

                    for (int inner = 0; inner < innerList.Count; inner++)
                    {

                        //print string
                    }
                }
                else
                {
                    //print string
                }
    }

我不想使用foreach循环，因为我不确定列表的顺序是否得到保证，并且将来会添加一个增量编号（可以由内部和外部变量）。

我得到的问题是错误：

inner < innerList.Count

是Operator '<' cannot be applied to operands of type 'int' and 'method group'

我需要做些什么来克服这个问题？我不确定这是实现最终结果的最有效方式，但是......

感谢您的帮助。

Answer 1

static void Main()
{
    var randomCrap = new List<Object>
    {
        1, "two",
        new List<object> { 3, 4 },
        5, 6,
        new List<object> {
            new List<object> { 7, 8, "nine" },
        },
    };

    randomCrap.PrintAll();
}

输出：

1
two
3
4
5
6
7
8
nine

使用此：

public static class Extensions
{
    public static void PrintAll(this Object root)
    {
        foreach (var x in root.SelectAll())
        {
            Console.WriteLine(x);
        }
    }

    public static IEnumerable<Object> SelectAll(this object o)
    {
        //  Thank you, eocron
        if (o is String)
        {
            yield return o;
        }
        else if (o is IEnumerable)
        {
            var e = o as IEnumerable;
            foreach (var child in e)
            {
                foreach (var child2 in child.SelectAll())
                    yield return child2;
            }
        }
        else
        {
            yield return o;
        }
    }
}

Answer 2

如果你知道你的对象是某种泛型类型的List<>，你总是可以强制转换为IList并以这种方式遍历它。

用你的代码来解释：

if (innerList.GetType().IsGenericType && innerList.GetType().GetGenericTypeDefinition() == typeof(List<>))
{
    var list = (IList)innerList;
    for (int inner = 0; inner < list.Count; inner++)
    {
        Console.WriteLine(list[inner].ToString());
        //print string
    }
}

但实际上，你应该按照其中所说的做，并使用覆盖ToString()或Display()方法制作强类型。

Answer 3

这是做你想做的更简单的方式：

public static void DeepPrint(object obj, int recursionLevel)
{
    if(obj == null)
    {
        //print null
        return;
    }
    var str = obj as string;
    if(str != null)
    {
        //print str
        return;
    }
    var enumer = obj as IEnumerable;
    if(enumer != null)
    {
        foreach(var e in enumer)
        {
            DeepPrint(e, recursionLevel+1);
        }
        return;
    }
    //print obj.ToString();
}

然后根据你的意愿这样称呼它：

DeepPrint(myObjectOrList, 0);

PS

对于那些说＆＃34;随机废话＆＃34; - 拥抱string.Format（...），一般包含序列化，包含WCF和动态等等。这个世界上有很多随机的东西，它们并不需要强类型。事实上，它将成为＆＃34;废话＆＃34;如果你为一些常用的函数提供强类型。

Answer 4

您可以做的一种方法是检查对象是否实现ICollection，如果是，则迭代内容。我创建了一个递归方法来处理集合包含其他集合的情况，其中包含一个indentAmount参数，以便嵌套集合在每次遇到时都会被标签缩进：

public static void PrintItem(object item, int indentAmount = 0)
{
    var indent = new string('\t', indentAmount);
    if (item == null) Console.WriteLine($"{indent}<null>");

    if (item is ICollection)
    {
        var innerItems = item as IEnumerable;
        Console.WriteLine($"{indent}Collection type encountered:");
        indentAmount++;
        foreach (var innerItem in innerItems)
        {
            PrintItem(innerItem, indentAmount);
        }
    }
    else
    {
        Console.WriteLine($"{indent}{item}");
    }
}

<强>用法

private static void Main()
{
    var items = new List<object>
    {
        "first",
        2,
        new List<string> {"listFirst", "listSecond"},
        new[] {"arrayFirst", "arraySecond"},
        new ArrayList {"arrayListFirst", "arrayListSecond"},
        "third",
        new List<List<string>>
        {
            new List<string> {"nestedList1First", "nestedList1Second"},
            new List<string> {"nestedList2First", "nestedList2Second"}
        },
        4f,
        new object[] {5d, "six", new List<object>{"seven", 8} },
        9,
        "ten"
    };

    PrintItem(items);

    Console.WriteLine("\nDone!\nPress any key to exit...");
    Console.ReadKey();
}

<强>输出

如何迭代混合List <t>并将内容打印到C＃中的控制台？

4 个答案: