为什么?!

如果你使用List，最简单的方法是使用for而不是foreach:

for (int i = 0 ; i < myList.Count ; i++)
{
    // Do something...
}

或者如果你想使用foreach:

foreach (string m in myList)
{
     // Do something...
}

你可以用它来知道每个循环的索引:

myList.indexOf(m)

我在LINQPad中构建了这个:

var listOfNames = new List<string>(){"John","Steve","Anna","Chris"};

var listCount = listOfNames.Count;

var NamesWithCommas = string.Empty;

foreach (var element in listOfNames)
{
    NamesWithCommas += element;
    if(listOfNames.IndexOf(element) != listCount -1)
    {
        NamesWithCommas += ", ";
    }
}

NamesWithCommas.Dump();  //LINQPad method to write to console.

你也可以使用string.join:

var joinResult = string.Join(",", listOfNames);

除非你的集合可以通过某种方法返回对象的索引，否则唯一的方法就是使用像你的例子中那样的计数器。

然而，当使用索引时，唯一合理的答案是使用for循环。其他任何事情都会带来代码的复杂性，更不用说时间和空间的复杂性了。

我不同意在大多数情况下使用for循环是更好的选择的说法。

Foreach是一个有用的构造，在所有情况下都不能被for循环所取代。

例如，如果您有一个DataReader，并使用foreach循环遍历所有记录，它会自动调用Dispose方法并关闭阅读器(然后自动关闭连接)。因此，这是更安全的，因为它可以防止连接泄漏，即使您忘记关闭读取器。

(当然，总是关闭读取器是很好的做法，但如果你不这样做，编译器就不会捕捉到它——你不能保证你已经关闭了所有的读取器，但你可以通过养成使用foreach的习惯，使它更有可能不会泄漏连接。)

对于Dispose方法的隐式调用，可能还有其他有用的例子。

我不确定你试图用基于问题的索引信息做什么。然而，在c#中，你通常可以使用IEnumerable。Select方法从您想要的任何内容中获取索引。例如，我可以使用类似这样的方法来判断一个值是奇数还是偶数。

string[] names = { "one", "two", "three" };
var oddOrEvenByName = names
    .Select((name, index) => new KeyValuePair<string, int>(name, index % 2))
    .ToDictionary(kvp => kvp.Key, kvp => kvp.Value);

这将根据列表中的项是奇数(1)还是偶数(0)的名称为您提供一个字典。

使用计数器变量并没有什么错。事实上，无论使用for、foreach while还是do，计数器变量都必须在某处声明并递增。

所以，如果你不确定你是否有一个适当索引的集合，请使用这个习语:

var i = 0;
foreach (var e in collection) {
   // Do stuff with 'e' and 'i'
   i++;
}

否则，如果你知道你的可索引集合是O(1)索引访问(它将是数组和可能List<T>(文档没有说)，但不一定对其他类型(如LinkedList)):

// Hope the JIT compiler optimises read of the 'Count' property!
for (var i = 0; i < collection.Count; i++) {
   var e = collection[i];
   // Do stuff with 'e' and 'i'
}

它应该永远不需要通过调用MoveNext()和询问Current来“手动”操作IEnumerator - foreach是为你省去了那个特别的麻烦…如果您需要跳过项目，只需在循环体中使用continue。

为了完整起见，根据你对索引的处理(上面的结构提供了足够的灵活性)，你可以使用Parallel LINQ:

// First, filter 'e' based on 'i',
// then apply an action to remaining 'e'
collection
    .AsParallel()
    .Where((e,i) => /* filter with e,i */)
    .ForAll(e => { /* use e, but don't modify it */ });

// Using 'e' and 'i', produce a new collection,
// where each element incorporates 'i'
collection
    .AsParallel()
    .Select((e, i) => new MyWrapper(e, i));

我们使用上面的AsParallel()，因为现在已经是2014年了，我们希望充分利用这些多核来加快速度。此外，对于“顺序”LINQ，你只能在List<T>和Array…上获得ForEach()扩展方法。而且不清楚使用它是否比简单的foreach更好，因为您仍然在运行单线程的更难看的语法。