C#、objectCollection.OfType() 和 foreach（objectCollection 中的 T 项）、IEnumerable 到 IEnumerable

Question

我个人的编码风格属于 Enumerable.OfType()。我在任何地方都使用它，它有点意义。特别是 IEnumerable 允许强大的 linqToObject 功能。我讨厌 ObjectCollections 的“类型不安全”循环，例如下面的示例。现在我有一些关于循环这些“UnGenericCollections”的问题。

• ConfigurationSectionCollection
• HttpModuleCollection
• SPBaseCollection
• SPFieldCollection
• ArrayList
• 等等...

问题 1：如果我将此 ArrayList 转换为 Enumerable 与简单的 foreach/if-checks 相比，额外的循环有多大？

var ark = new ArrayList();
ark.Add(new Human());
ark.Add(new Human());
ark.Add(new Animal());

而不是：

foreach (object passenger in ark)
{
    if (passanger is Human) { }
    if (passanger is Animal) { }
}

我使用：

foreach (var human in ark.OfType<Human>())
{
}

foreach (var animal in ark.OfType<Animal>())
{
}

问题 2： 在 foreach 循环到不同类型的变量期间，将使用哪种强制转换/转换方式？这是一种语言功能还是开箱即用？

foreach (Human human in ark) { }

谢谢你忍受我糟糕的英语。最好的问候，本杰明

Answer 1

Ans 1：

在您的示例中 - 您实际上可能会迭代 FULL 枚举两次。

// i use
foreach (var human in ark.OfType<Human>())
{
}

foreach (var animal in ark.OfType<Animal>())
{
}

Ans 2：

如果方舟中存在非人类，则会抛出 InvalidCastException 异常。

我个人更喜欢 ark.OfTypes()，以防我知道我只想处理 Human 和 Animals 但会忽略精灵。这样代码更加简洁，并且您在 foreach 循环中处理强类型对象。

但同样，如果我不想忽略 Elves，我宁愿迭代完整的 ArrayList 并使用强制转换。

Answer 2

由于 ArrayList 实现了 IEnumerable，因此您不会发现任何差异。实际上，任何实现此接口的东西都可以在 foreach 语句中使用。

将构建转换对象而不是设置 var（因为它是显式转换），但如果枚举中有动物，则最终将不得不处理转换异常。

foreach (Animal animal in ark) { } // this will blow up an exception if the object is Human

Answer 3

为了防止集合被迭代两次并保持某种甜蜜的语法，我提供了一个扩展方法，允许链接指定类型的 foreach。
我觉得这会很有趣：

    static void Main(string[] args)
    {
        var ugly = new ArrayList();
        ugly.Add("strings are evil");
        ugly.Add("yeah");
        ugly.Add(1);
        ugly.Add(3);
        ugly.Add(1234);
        ugly.WithType<int>(x => Console.WriteLine("im a lousy int! " + x))
            .AndType<string>(x => Console.WriteLine("and im dangerous string: " + x))
            .Execute();
        Console.ReadKey();
    }

    static TypedCollectionView WithType<T>(this IEnumerable x, Action<T> action)
    {
        return new TypedCollectionView(x).AndType(action);
    }

    class TypedCollectionView
    {
        private readonly IEnumerable collection;
        private readonly Dictionary<Type, Action<object>> actions = new Dictionary<Type, Action<object>>();

        public TypedCollectionView(IEnumerable collection)
        {
            this.collection = collection;
        }

        public TypedCollectionView AndType<T>(Action<T> action)
        {
            actions.Add(typeof(T), o => action((T)o));
            return this;
        }

        public void Execute()
        {
            foreach (var item in collection)
            {
                var itemType = item.GetType();
                foreach (var action in actions.Where(kv.Key.IsAssignableFrom(itemType)).Select(kv.Value))
                {
                    action(item);
                }
            }
        }
    }

所以..现在如何让这件事变得不那么糟糕？ ：D

Answer 4

Enumerable.OfType 将遍历所有元素并为您执行 is T 检查。因此，每个 OfType 调用都会迭代集合中的所有元素。那一定会慢一些。但如果它慢到你不应该在你的程序中这样做，那就是另一回事了。

我认为将没有相同父级的类的对象放入一个集合中是否有意义。也许您可以找到一些抽象，然后在 foreach 中将所有对象强制转换为基类并使用多态调用。