什么时候用哪个?

When to use which for?(什么时候用哪个?)

问题描述

编辑下面的附加选项和稍微扩展的问题.

EDIT Additional options and a slightly extended question below.

考虑这个类体的人为的抽象示例.它演示了执行for"迭代的四种不同方式.

Consider this contrived and abstract example of a class body. It demonstrates four different ways of performing a "for" iteration.

private abstract class SomeClass
{
    public void someAction();
}

void Examples()
{
    List<SomeClass> someList = new List<SomeClass>();

    //A. for
    for (int i = 0; i < someList.Count(); i++)
    {
        someList[i].someAction();
    }

    //B. foreach
    foreach (SomeClass o in someList)
    {
        o.someAction();
    }

    //C. foreach extension
    someList.ForEach(o => o.someAction());

    //D. plinq
    someList.AsParallel().ForAll(o => o.someAction());

从答案和研究中添加一些选项.

Addition of some options from answers and research.

    //E. ParallelEnumerable
    ParallelEnumerable.Range(0, someList.Count - 1)
        .ForAll(i => someList[i].someAction());

    //F. ForEach Parallel Extension
    Parallel.ForEach(someList, o => o.someAction());

    //G. For Parallel Extension
    Parallel.For(0, someList.Count - 1, i => someList[i].someAction())
}

我的问题分为两部分.我错过了一些重要的选择吗?考虑到可读性但主要是性能，哪个选项是最佳选择?

My question comes in two parts. Have I missed some significant option? Which option is the best choice, considering readability but primarily performance?

请说明 SomeClass 实现的复杂性或 someList 的 Count 是否会影响此选择.

Please indicate if the complexity of the SomeClass implementation, or the Count of someList would effect this choice.

有了这么多令人眼花缭乱的选项，我不希望我的代码被选择破坏.要为我的问题添加第三部分，如果我的列表可以是任意长度，我应该默认为并行选项吗?

With such a dizzying array of options, I wouldn't like my code to be spoilt by choice. To add a thrid part to my question, If my list could be any length should I default to a parallel option?

作为一个稻草人.我怀疑 SomeClass 的所有实现和 someList 选项 //E 的所有长度.考虑到多处理器架构的普遍性，ParallelEnumerable 将提供最佳的平均性能.我没有做任何测试来证明这一点.

As a straw man. I suspect that over all implementations of SomeClass and all lengths of someList option //E. ParallelEnumerable would offer the best average performance, given the prevalanece of multi processor architechtures. I haven't done any testing to prove this.

注意:并行扩展需要使用 System.Threading.Tasks 命名空间.

Note: The parallel extensions will require the use of the System.Threading.Tasks namespace.

推荐答案

选项 A 仅对实现索引的序列才真正有意义，并且仅对具有 O(1) 查找时间的序列有效.一般来说，我会使用 foreach 和变体，除非你有特殊的逻辑.

Option A only really makes sense for sequences that implement indexing and will only be performant for those that have O(1) lookup time. Generally, I would use the foreach and variants unless you have special logic.

还要注意，像 for (int i = 1; i 这样的特殊逻辑"可以用 Linq 扩展方法实现:foreach(var item按顺序跳过(1)).