C # foreach улучшения?

Я часто сталкиваюсь с этим во время программирования, когда я хочу иметь индекс числа циклов внутри foreach и должен создавать целое число, использовать его, увеличивать и т. Д. Не было бы хорошей идеей, если было введено ключевое слово, которое было количество циклов внутри foreach? Это также может быть использовано в других циклах.

Идет ли это против использования ключевых слов, поскольку компилятор не позволяет использовать это ключевое слово где-либо, кроме как в циклической конструкции?

Если вам нужно количество циклов внутри foreachцикла, почему бы вам просто не использовать обычный forцикл. foreachПетля была предназначена , чтобы сделать определенные виды использования forпетель более простых. Похоже, у вас есть ситуация, когда простота foreachбольше не является выгодной.

Вы можете использовать анонимные типы, как это

foreach (var item in items.Select((v, i) => new { Value = v, Index = i }))
{
    Console.WriteLine("Item value is {0} and index is {1}.", item.Value, item.Index);
}

Это похоже на enumerateфункцию Python

for i, v in enumerate(items):
    print v, i

Я просто добавляю ответ Дана Финча здесь, как и просил.

Не дай мне очков, дай очки Дану Финчу :-)

Решением является написание следующего общего метода расширения:

public static void Each<T>( this IEnumerable<T> ie, Action<T, int> action )
{
    var i = 0;
    foreach ( var e in ie ) action( e, i++ );
}

Который используется так:

var strings = new List<string>();
strings.Each( ( str, n ) =>
{
    // hooray
} );

Я могу ошибаться по этому поводу, но я всегда думал, что основной целью цикла foreach было упрощение итерации со дней STL в C ++, т.е.

for(std::stltype<typename>::iterator iter = stl_type_instance.begin(); iter != stl_type_instance.end(); iter++)
{
   //dereference iter to use each object.
}

сравните это с использованием .NET IEnumerable в foreach

foreach(TypeName instance in DescendentOfIEnumerable)
{
   //use instance to use the object.
}

последнее намного проще и позволяет избежать многих старых ошибок. Кроме того, они, кажется, следуют почти одинаковым правилам. Например, вы не можете изменить содержимое IEnumerable внутри цикла (что имеет гораздо больше смысла, если вы думаете об этом в стиле STL). Однако цикл for часто имеет другое логическое назначение, чем итерация.

Если рассматриваемая коллекция является IList<T>, вы можете просто использовать forс индексацией:

for (int i = 0; i < collection.Count; i++)
{
    var item = collection[i];
    // …
}

Если нет, то вы могли бы использовать Select(), это имеет перегрузку, которая дает вам индекс.

Если это также не подходит, я думаю, что поддерживать этот индекс вручную достаточно просто, это всего лишь две очень короткие строки кода. Создание ключевого слова специально для этого было бы излишним.

int i = 0;
foreach (var item in collection)
{
    // …
    i++;
}

Если все, что вы знаете, это то, что коллекция является IEnumerable, но вам нужно отслеживать, сколько элементов вы обработали до сих пор (и, следовательно, общее количество, когда вы закончите), вы можете добавить пару строк в базовый цикл for:

var coll = GetMyCollectionAsAnIEnumerable();
var idx = 0;
for(var e = coll.GetEnumerator(); e.MoveNext(); idx++)
{
   var elem = e.Current;

   //use elem and idx as you please
}

Вы также можете добавить инкрементную переменную индекса в foreach:

var i=0;
foreach(var elem in coll)
{
   //do your thing, then...
   i++;
}

Если вы хотите, чтобы это выглядело более элегантно, вы можете определить метод расширения или два, чтобы «скрыть» эти детали:

public static void ForEach<T>(this IEnumerable<T> input, Action<T> action)
{
    foreach(T elem in input)
        action(elem);
}

public static void ForEach<T>(this IEnumerable<T> input, Action<T, int> action)
{
    var idx = 0;
    foreach(T elem in input)
        action(elem, idx++); //post-increment happens after parameter-passing
}

//usage of the index-supporting method
coll.ForEach((e, i)=>Console.WriteLine("Element " + (i+1) + ": " + e.ToString()));

Scoping также работает, если вы хотите сохранить блок в чистоте от столкновений с другими именами ...

{ int index = 0; foreach(var el in List) { Console.WriteLine(el + " @ " + index++); } }

Для этого я использую whileцикл. Циклы forтакже работают, и многие люди предпочитают их, но мне нравится использовать только forто, что будет иметь фиксированное количество итераций. IEnumerables может генерироваться во время выполнения, так что, на мой взгляд, whileимеет больше смысла. Назовите это неофициальное руководство по кодированию, если хотите.