Как получить индекс текущей итерации цикла foreach?

foreach предназначен для перебора коллекций, реализующих 9X_.cs-file IEnumerable. Он делает это, вызывая GetEnumerator для коллекции, которая 9X_c#-language возвращает Enumerator.

Этот перечислитель имеет метод 9X_c#-language и свойство:

• MoveNext()
• Current

Current возвращает объект, на котором 9X_c# Enumerator в данный момент находится, MoveNext обновляет 9X_foreach Current на следующий объект.

Концепция индекса чужда 9X_c#-language концепции перечисления и не может быть реализована.

Из-за 9X_c-sharp этого большинство коллекций можно просматривать 9X_csharp с помощью индексатора и конструкции цикла 9X_c#.net for.

В этой ситуации я предпочитаю использовать 9X_c#.net цикл for, а не отслеживать индекс с помощью 9X_csharp локальной переменной.

Наконец, C# 7 имеет достойный синтаксис 9X_c#.net для получения индекса внутри цикла foreach (т.е. кортежи):

foreach (var (item, index) in collection.WithIndex()) { Debug.WriteLine($"{index}: {item}"); } 

Потребуется 9X_enhanced-for-loop небольшой метод расширения:

public static IEnumerable<(T item, int index)> WithIndex(this IEnumerable self) => self.Select((item, index) => (item, index)); 

Можно сделать что-то вроде этого:

public static class ForEachExtensions { public static void ForEachWithIndex(this IEnumerable enumerable, Action handler) { int idx = 0; foreach (T item in enumerable) handler(item, idx++); } } public class Example { public static void Main() { string[] values = new[] { "foo", "bar", "baz" }; values.ForEachWithIndex((item, idx) => Console.WriteLine("{0}: {1}", idx, item)); } } 

9X_c#.net

Я не согласен с комментариями о том, что 9X_c#-language в большинстве случаев лучше использовать 9X_.cs-file цикл for.

foreach - полезная конструкция, которую нельзя 9X_c-sharp заменить циклом for ни при каких обстоятельствах.

Например, если 9X_csharp у вас есть DataReader и вы просматриваете все записи 9X_foreach в цикле с помощью foreach, он автоматически вызывает 9X_foreach метод Dispose и закрывает считыватель (который 9X_foreach затем может закрыть соединение автоматически). Таким 9X_foreach образом, это безопаснее, поскольку предотвращает 9X_c# утечку соединения, даже если вы забыли закрыть 9X_c#.net считыватель.

(Конечно, это хорошая практика 9X_csharp - всегда закрывать читатели, но компилятор 9X_.cs-file не поймает это, если вы этого не сделаете 9X_c-sharp - вы не можете гарантировать, что закрыли 9X_enhanced-for-loop все читатели, но вы можете сделать это с 9X_foreach большей вероятностью, что не будет утечки 9X_c-sharp подключений, привыкнув использовать foreach.)

Могут 9X_foreach быть и другие примеры полезного неявного 9X_c#.net вызова метода Dispose.

Дословный ответ — предупреждение, производительность 9X_enhanced-for-loop может быть не такой хорошей, как простое 9X_c# использование int для отслеживания индекса. По 9X_c#.net крайней мере, это лучше, чем использовать 9X_c-sharp IndexOf.

Вам просто нужно использовать перегруженную 9X_foreach индексацию Select, чтобы обернуть каждый 9X_foreach-loop элемент в коллекции анонимным объектом, который 9X_c-sharp знает индекс. Это можно сделать против всего, что 9X_visual-c# реализует IEnumerable.

System.Collections.IEnumerable collection = Enumerable.Range(100, 10); foreach (var o in collection.OfType

Используя LINQ, C# 7 и пакет NuGet System.ValueTuple, вы 9X_c#.net можете сделать следующее:

foreach (var (value, index) in collection.Select((v, i)=>(v, i))) { Console.WriteLine(value + " is at index " + index); } 

Вы можете использовать 9X_visual-c# обычную конструкцию foreach и иметь возможность 9X_visual-c# напрямую обращаться к значению и индексу, а 9X_foreach не как член объекта, и сохранять оба поля 9X_.cs-file только в пределах цикла. По этим причинам 9X_visual-c# я считаю, что это лучшее решение, если вы 9X_enhanced-for-loop можете использовать C# 7 и System.ValueTuple.

Нет ничего плохого в использовании переменной 9X_foreach-loop счетчика. Фактически, независимо от того, используете 9X_c#.net ли вы for, foreach while или do, переменная счетчика должна 9X_.cs-file быть где-то объявлена ​​и увеличена.

Поэтому 9X_c#.net используйте эту идиому, если вы не уверены, что 9X_c# у вас есть соответствующая проиндексированная 9X_foreach коллекция:

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

Иначе используйте этот, если вы 9X_c# знаете, что ваша индексируемая коллекция - O (1) для доступа 9X_c#.net к индексу (что будет для Array и, вероятно, для 9X_foreach-loop List (в документации не сказано), но не обязательно 9X_enhanced-for-loop для других типов (например, 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' } 

Никогда не 9X_c#.net должно быть необходимости «вручную» управлять 9X_foreach IEnumerator, вызывая MoveNext() и запрашивая Current - foreach избавляет вас 9X_c#.net от этой конкретной проблемы ... если вам 9X_csharp нужно пропустить элементы, просто используйте 9X_c-sharp continue в теле цикла.

И просто для полноты, в зависимости 9X_c-sharp от того, что вы делали со своим индексом (приведенные 9X_foreach выше конструкции предлагают большую гибкость), вы 9X_c# можете использовать 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)); 

Мы используем 9X_csharp AsParallel() выше, потому что уже 2014 год, и мы хотим 9X_.cs-file эффективно использовать эти несколько ядер, чтобы 9X_.cs-file ускорить процесс. Кроме того, для «последовательного» LINQ, you only get a ForEach() extension method on List and Array ... и 9X_c#-language непонятно, лучше ли его использовать, чем 9X_c#-language простой foreach, поскольку вы все еще используете 9X_enhanced-for-loop однопоточную схему для более уродливого 9X_enhanced-for-loop синтаксиса.

Используя ответ @ FlySwat, я придумал следующее 9X_csharp решение:

//var list = new List { 1, 2, 3, 4, 5, 6 }; // Your sample collection var listEnumerator = list.GetEnumerator(); // Get enumerator for (var i = 0; listEnumerator.MoveNext() == true; i++) { int currentItem = listEnumerator.Current; // Get current item. //Console.WriteLine("At index {0}, item is {1}", i, currentItem); // Do as you wish with i and currentItem } 

Вы получаете перечислитель с помощью 9X_enhanced-for-loop GetEnumerator, а затем выполняете цикл с помощью цикла 9X_c-sharp for. Однако хитрость заключается в том, чтобы 9X_foreach сделать условие цикла listEnumerator.MoveNext() == true.

Поскольку метод перечислителя 9X_visual-c# MoveNext возвращает истину, если есть следующий 9X_csharp элемент и к нему можно получить доступ, условие 9X_foreach-loop цикла останавливает цикл, когда у нас заканчиваются 9X_.cs-file элементы для перебора.

Просто добавьте свой индекс. Будьте проще.

int i = 0; foreach (var item in Collection) { item.index = i; ++i; } 

9X_foreach

Вы можете заключить исходный перечислитель 9X_csharp в другой, который действительно содержит 9X_c# информацию об индексе.

foreach (var item in ForEachHelper.WithIndex(collection)) { Console.Write("Index=" + item.Index); Console.Write(";Value= " + item.Value); Console.Write(";IsLast=" + item.IsLast); Console.WriteLine(); } 

Вот код класса ForEachHelper.

public static class ForEachHelper { public sealed class Item { public int Index { get; set; } public T Value { get; set; } public bool IsLast { get; set; } } public static IEnumerable> WithIndex(IEnumerable enumerable) { Item item = null; foreach (T value in enumerable) { Item next = new Item(); next.Index = 0; next.Value = value; next.IsLast = false; if (item != null) { next.Index = item.Index + 1; yield return item; } item = next; } if (item != null) { item.IsLast = true; yield return item; } } } 

Вот решение, которое я только что придумал 9X_.cs-file для этой проблемы

Исходный код:

int index=0; foreach (var item in enumerable) { blah(item, index); // some code that depends on the index index++; } 

Обновленный код

enumerable.ForEach((item, index) => blah(item, index)); 

Метод расширения:

 public static IEnumerable ForEach(this IEnumerable enumerable, Action action) { var unit = new Unit(); // unit is a new type from the reactive framework (http://msdn.microsoft.com/en-us/devlabs/ee794896.aspx) to represent a void, since in C# you can't return a void enumerable.Select((item, i) => { action(item, i); return unit; }).ToList(); return pSource; } 

Почему именно foreach?!

Самый простой способ - использовать for вместо 9X_foreach foreach , если вы используете List:

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

Или, если вы хотите использовать 9X_c# foreach:

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

Вы можете использовать это, чтобы 9X_c# узнать индекс каждого цикла:

myList.indexOf(m) 

C# 7 наконец-то дает нам элегантный способ 9X_c#-language сделать это:

static class Extensions { public static IEnumerable<(int, T)> Enumerate( this IEnumerable input, int start = 0 ) { int i = start; foreach (var t in input) { yield return (i++, t); } } } class Program { static void Main(string[] args) { var s = new string[] { "Alpha", "Bravo", "Charlie", "Delta" }; foreach (var (i, t) in s.Enumerate()) { Console.WriteLine($"{i}: {t}"); } } } 

Это будет работать только для списка, а 9X_foreach не для любого IEnumerable, но в LINQ есть 9X_foreach это:

IList

@Jonathan Я не сказал, что это отличный 9X_c-sharp ответ, я просто сказал, что он просто показывает, что 9X_visual-c# можно сделать то, что он просил :)

@Graphain 9X_foreach-loop Я бы не ожидал, что он будет быстрым - я 9X_enhanced-for-loop не совсем уверен, как он работает, он может 9X_c#.net каждый раз повторять весь список, чтобы 9X_foreach найти соответствующий объект, что было бы 9X_enhanced-for-loop чертовски много сравнений.

Тем не менее, List 9X_visual-c# может хранить индекс каждого объекта вместе 9X_foreach со счетчиком.

У Джонатана, кажется, есть 9X_csharp идея получше, если он уточнит?

Было бы лучше 9X_csharp просто вести подсчет того, где вы находитесь 9X_enhanced-for-loop в foreach, хотя это проще и адаптируемее.

Этот ответ: лоббируйте языковую группу C# для 9X_.cs-file прямой языковой поддержки.

Первый ответ гласит:

Очевидно, что 9X_foreach понятие индекса чуждо концепции перечисление 9X_foreach и не может быть выполнено.

Хотя это верно 9X_c#.net для текущей версии языка C# (2020), это 9X_visual-c# не концептуальное ограничение CLR / языка, это 9X_visual-c# можно сделать.

Команда разработчиков языка 9X_c#-language Microsoft C# могла бы создать новую функцию 9X_visual-c# языка C#, добавив поддержку нового интерфейса 9X_foreach-loop IIndexedEnumerable

foreach (var item in collection with var index) { Console.WriteLine("Iteration {0} has value {1}", index, item); } //or, building on @user1414213562's answer foreach (var (item, index) in collection) { Console.WriteLine("Iteration {0} has value {1}", index, item); } 

Если используется foreach () и присутствует 9X_visual-c# with var index, то компилятор ожидает, что коллекция элементов 9X_c#-language объявит интерфейс IIndexedEnumerable. Если интерфейс отсутствует, компилятор 9X_.cs-file может полифиллом обернуть источник объектом 9X_c-sharp IndexedEnumerable, который добавляет в код 9X_.cs-file для отслеживания индекса.

interface IIndexedEnumerable : IEnumerable { //Not index, because sometimes source IEnumerables are transient public long IterationNumber { get; } } 

Позже среда CLR 9X_.cs-file может быть обновлена, чтобы иметь внутреннее 9X_c-sharp отслеживание индекса, которое используется 9X_foreach-loop только в том случае, если указано ключевое 9X_c-sharp слово with и источник не реализует напрямую 9X_c-sharp IIndexedEnumerable

Почему:

• Foreach выглядит лучше, а в бизнес-приложениях циклы foreach редко являются узким местом производительности.
• Foreach может более эффективно использовать память. Наличие конвейера функций вместо преобразования в новые коллекции на каждом этапе. Кого волнует, использует ли он несколько больше циклов ЦП, когда меньше отказов кеш-памяти ЦП и меньше сборок мусора?
• Требование от кодировщика добавить код отслеживания индекса портит красоту
• Его довольно легко реализовать (пожалуйста, Microsoft), и он обратно совместим.

Хотя большинство людей здесь не являются 9X_c#-language сотрудниками Microsoft, это правильный 9X_csharp ответ, вы можете лоббировать Microsoft, чтобы 9X_foreach-loop добавить такую ​​функцию. Вы уже можете 9X_c# создать свой собственный итератор с extension function and use tuples, но 9X_c#-language Microsoft может добавить синтаксический 9X_c#-language сахар, чтобы избежать функции расширения

Я делаю это так, что приятно своей простотой 9X_enhanced-for-loop / краткостью, но если вы много делаете в 9X_c-sharp теле цикла obj.Value, он довольно быстро устареет.

foreach(var obj in collection.Select((item, index) => new { Index = index, Value = item }) { string foo = string.Format("Something[{0}] = {1}", obj.Index, obj.Value); ... } 

int index; foreach (Object o in collection) { index = collection.indexOf(o); } 
Это будет работать для коллекций, поддерживающих 9X_c#-language IList.

//using foreach loop how to get index number: foreach (var result in results.Select((value, index) => new { index, value })) { //do something } 
9X_c#-language

Лучше использовать ключевое слово continue безопасную 9X_c# конструкцию, подобную этой

int i=-1; foreach (Object o in collection) { ++i; //... continue; //<--- safe to call, index will be increased //... } 

Вы можете написать свой цикл следующим образом:

var s = "ABCDEFG"; foreach (var item in s.GetEnumeratorWithIndex()) { System.Console.WriteLine("Character: {0}, Position: {1}", item.Value, item.Index); } 

После 9X_.cs-file добавления следующей структуры и метода 9X_foreach-loop расширения.

Структура и метод расширения 9X_foreach инкапсулируют функциональность Enumerable.Select.

public struct ValueWithIndex { public readonly T Value; public readonly int Index; public ValueWithIndex(T value, int index) { this.Value = value; this.Index = index; } public static ValueWithIndex Create(T value, int index) { return new ValueWithIndex(value, index); } } public static class ExtensionMethods { public static IEnumerable> GetEnumeratorWithIndex(this IEnumerable enumerable) { return enumerable.Select(ValueWithIndex.Create); } } 

Если коллекция представляет собой список, вы 9X_c# можете использовать List.IndexOf, например:

foreach (Object o in collection) { // ... @collection.IndexOf(o) } 

Для интереса Фил Хаак только что написал 9X_c#.net пример этого в контексте Razor Templated 9X_c-sharp Delegate (http://haacked.com/archive/2011/04/14/a-better-razor-foreach-loop.aspx)

Фактически он пишет метод расширения, который 9X_.cs-file оборачивает итерацию в класс «IteratedItem» (см. ниже), предоставляя 9X_c#-language доступ как к индексу, так и к элементу во 9X_c#.net время итерации.

public class IndexedItem { public IndexedItem(int index, TModel item) { Index = index; Item = item; } public int Index { get; private set; } public TModel Item { get; private set; } } 

Однако, хотя это было бы 9X_visual-c# нормально в среде, отличной от Razor, если 9X_c#-language вы выполняете одну операцию (т. е. ту, которая 9X_c#.net может быть предоставлена ​​как лямбда), это 9X_c-sharp не будет надежной заменой синтаксиса for 9X_c#.net / foreach в non-Razor. -Razor контексты.

Мое решение этой проблемы - метод расширения 9X_.cs-file WithIndex(),

http://code.google.com/p/ub-dotnet-utilities/source/browse/trunk/Src/Utilities/Extensions/EnumerableExtensions.cs

Используйте это как

var list = new List { 1, 2, 3, 4, 5, 6 }; var odd = list.WithIndex().Where(i => (i.Item & 1) == 1); CollectionAssert.AreEqual(new[] { 0, 2, 4 }, odd.Select(i => i.Index)); CollectionAssert.AreEqual(new[] { 1, 3, 5 }, odd.Select(i => i.Item)); 

Я не думаю, что это должно быть достаточно 9X_c# эффективным, но это работает:

@foreach (var banner in Model.MainBanners) { @Model.MainBanners.IndexOf(banner) } 

Я построил это в LINQPad:

var listOfNames = new List(){"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. 

Вы также можете просто 9X_csharp использовать string.join:

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

У меня только что возникла эта проблема, но 9X_foreach-loop обдумывание проблемы в моем случае дало 9X_foreach-loop лучшее решение, не связанное с ожидаемым 9X_csharp решением.

Это может быть довольно распространенный 9X_.cs-file случай, в основном, я читаю из одного исходного 9X_foreach списка и создаю на их основе объекты в целевом 9X_foreach списке, однако мне нужно сначала проверить, действительны 9X_.cs-file ли исходные элементы, и я хочу вернуть строка 9X_csharp любой ошибки. На первый взгляд, я хочу получить 9X_.cs-file индекс в перечислителе объекта в свойстве 9X_enhanced-for-loop Current, однако, копируя эти элементы, я 9X_csharp в любом случае неявно знаю текущий индекс 9X_foreach-loop из текущего места назначения. Очевидно, это 9X_enhanced-for-loop зависит от вашего целевого объекта, но для 9X_foreach-loop меня это был список, и, скорее всего, он 9X_visual-c# будет реализовывать ICollection.

т.е.

var destinationList = new List(); foreach (var item in itemList) { var stringArray = item.Split(new char[] { ';', ',' }, StringSplitOptions.RemoveEmptyEntries); if (stringArray.Length != 2) { //use the destinationList Count property to give us the index into the stringArray list throw new Exception("Item at row " + (destinationList.Count + 1) + " has a problem."); } else { destinationList.Add(new someObject() { Prop1 = stringArray[0], Prop2 = stringArray[1]}); } } 

Не всегда 9X_c# применимо, но, я думаю, достаточно часто, чтобы 9X_foreach о нем стоило упомянуть.

В любом случае, дело 9X_visual-c# в том, что иногда в вашей логике уже есть 9X_c#.net неочевидное решение ...

Если ваша коллекция не может вернуть индекс 9X_c# объекта каким-либо методом, единственный 9X_.cs-file способ — использовать счетчик, как в вашем 9X_enhanced-for-loop примере.

Однако при работе с индексами единственным 9X_.cs-file разумным решением проблемы является использование 9X_c#.net цикла for. Все остальное усложняет код, не 9X_foreach говоря уже о временной и пространственной 9X_.cs-file сложности.

Таким образом, вы можете использовать индекс 9X_c# и значение с помощью LINQ:

ListValues.Select((x, i) => new { Value = x, Index = i }).ToList().ForEach(element => { // element.Index // element.Value }); 

Я не верю, что есть способ получить значение 9X_.cs-file текущей итерации цикла foreach. Считать 9X_c# себя, кажется, лучший способ.

Могу я спросить, почему 9X_enhanced-for-loop вы хотели бы знать?

Кажется, что вы, скорее 9X_c#-language всего, будете делать одну из трех вещей:

1) Получение 9X_c# предмета из коллекции, но в данном случае 9X_csharp он у вас уже есть.

2) Подсчет объектов для 9X_foreach последующей обработки... у коллекций есть 9X_c-sharp свойство Count, которое вы могли бы использовать.

3) Установка 9X_c#.net свойства объекта на основе его порядка в 9X_enhanced-for-loop цикле... хотя вы могли бы легко установить 9X_c-sharp это при добавлении объекта в коллекцию.

Я не понял, что вы пытались сделать с информацией 9X_c#.net индекса, основываясь на вопросе. Однако 9X_.cs-file в C# вы обычно можете адаптировать метод 9X_c#-language IEnumerable.Select, чтобы получить индекс 9X_enhanced-for-loop из того, что вы хотите. Например, я могу 9X_c#.net использовать что-то подобное, чтобы определить, четное 9X_csharp или нечетное значение.

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

Это даст вам словарь 9X_visual-c# по названию того, был ли элемент в списке 9X_c#-language нечетным (1) или четным (0).

Как насчет этого? Обратите внимание, что 9X_enhanced-for-loop myDelimitedString может иметь значение null, если 9X_.cs-file myEnumerable пусто.

IEnumerator enumerator = myEnumerable.GetEnumerator(); string myDelimitedString; string current = null; if( enumerator.MoveNext() ) current = (string)enumerator.Current; while( null != current) { current = (string)enumerator.Current; } myDelimitedString += current; if( enumerator.MoveNext() ) myDelimitedString += DELIMITER; else break; }