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

Есть ли какая-то редкая языковая конструкция, с которой я не сталкивался (например, немногие, которые я недавно выучил, некоторые по переполнению стека) в C # для получения значения, представляющего текущую итерацию цикла foreach?

Например, в настоящее время я делаю что-то вроде этого в зависимости от обстоятельств:

int i = 0;
foreach (Object o in collection)
{
    // ...
    i++;
}

Это foreachдля перебора коллекций, которые реализуют IEnumerable. Это делается путем вызова GetEnumeratorколлекции, которая вернет Enumerator.

Этот перечислитель имеет метод и свойство:

• MoveNext ()
• Текущий

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

Понятие индекса чуждо понятию перечисления и не может быть сделано.

По этой причине большинство коллекций можно просматривать с помощью индексатора и конструкции цикла for.

Я очень предпочитаю использовать цикл for в этой ситуации по сравнению с отслеживанием индекса с помощью локальной переменной.

Ян Мерсер опубликовал подобное решение в блоге Фила Хаака :

foreach (var item in Model.Select((value, i) => new { i, value }))
{
    var value = item.value;
    var index = item.i;
}

Это получает вас item ( item.value) и его index ( item.i), используя перегрузку LINQSelect :

второй параметр функции [inside Select] представляет индекс исходного элемента.

new { i, value }Создает новый анонимный объект .

Распределения кучи можно избежать, ValueTupleесли вы используете C # 7.0 или новее:

foreach (var item in Model.Select((value, i) => ( value, i )))
{
    var value = item.value;
    var index = item.i;
}

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

<ol>
foreach ((MyType value, Int32 i) in Model.Select((value, i) => ( value, i )))
{
    <li id="item_@i">@value</li>
}
</ol>

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

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

Небольшой метод расширения будет необходимо:

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

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

public static class ForEachExtensions
{
    public static void ForEachWithIndex<T>(this IEnumerable<T> enumerable, Action<T, int> 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));
    }
}

Я не согласен с комментариями о том, что forцикл является лучшим выбором в большинстве случаев.

foreachявляется полезной конструкцией и не может быть заменена forциклом при любых обстоятельствах.

Например, если у вас есть DataReader и вы перебираете все записи, используя его, foreachон автоматически вызывает метод Dispose и закрывает читатель (который затем может автоматически закрыть соединение). Поэтому это безопаснее, так как предотвращает утечки соединения, даже если вы забыли закрыть ридер.

(Конечно, это хорошая практика - всегда закрывать читатели, но компилятор не поймает его, если вы этого не сделаете - вы не можете гарантировать, что закрыли все читатели, но вы можете сделать это с большей вероятностью, что не будете пропускать соединения, получая в привычке использовать foreach.)

Могут быть и другие примеры использования неявного вызова Disposeметода.

Литеральный ответ - предупреждение, производительность может быть не такой хорошей, как при использовании intдля отслеживания индекса. По крайней мере, это лучше, чем использовать IndexOf.

Вам просто нужно использовать перегрузку индексации Select, чтобы обернуть каждый элемент в коллекции анонимным объектом, который знает индекс. Это может быть сделано против всего, что реализует IEnumerable.

System.Collections.IEnumerable collection = Enumerable.Range(100, 10);

foreach (var o in collection.OfType<object>().Select((x, i) => new {x, i}))
{
    Console.WriteLine("{0} {1}", o.i, o.x);
}

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

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

Вы можете использовать обычную foreachконструкцию и иметь возможность прямого доступа к значению и индексу, а не как к элементу объекта, и оба поля сохраняются только в области действия цикла. По этим причинам я считаю, что это лучшее решение, если вы можете использовать C # 7 и System.ValueTuple.

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

//var list = new List<int> { 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
}

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

Так как MoveNextметод перечислителя возвращает true, если есть следующий элемент, и к нему можно получить доступ, то условие цикла делает остановку цикла, когда у нас заканчиваются элементы для итерации.

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

Так что используйте эту идиому, если вы не уверены, что у вас есть соответственно проиндексированная коллекция:

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

В противном случае используйте этот, если вы знаете, что ваша индексируемая коллекция O (1) для доступа к индексу (для чего она Arrayи, вероятно, будет использоваться 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'
}

Никогда не должно быть необходимости «вручную» управлять IEnumeratorоперацией, вызывая MoveNext()и опрашивая Current- foreachэто спасает вас от этой конкретной проблемы ... если вам нужно пропустить элементы, просто используйте a 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 вы используете только ForEach()метод расширения List<T>иArray ... и не ясно, что его использование лучше, чем простое foreach, поскольку вы все еще используете однопоточный для более уродливого синтаксиса.

Вы могли бы обернуть оригинальный перечислитель другим, который содержит информацию индекса.

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<T>
    {
        public int Index { get; set; }
        public T Value { get; set; }
        public bool IsLast { get; set; }
    }

    public static IEnumerable<Item<T>> WithIndex<T>(IEnumerable<T> enumerable)
    {
        Item<T> item = null;
        foreach (T value in enumerable)
        {
            Item<T> next = new Item<T>();
            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;
        }            
    }
}

Вот решение, которое я только что придумал для этой проблемы

Оригинальный код:

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<T> ForEach<T>(this IEnumerable<T> enumerable, Action<T, int> 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;
    }

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

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

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

IList<Object> collection = new List<Object> { 
    new Object(), 
    new Object(), 
    new Object(), 
    };

foreach (Object o in collection)
{
    Console.WriteLine(collection.IndexOf(o));
}

Console.ReadLine();

@ Джонатан Я не сказал, что это был отличный ответ, я просто сказал, что он просто показывает, что можно сделать то, что он просил :)

@Graphain Я бы не ожидал, что он будет быстрым - я не совсем уверен, как это работает, он может повторять весь список каждый раз, чтобы найти соответствующий объект, который был бы адским сравнением.

Тем не менее, List может хранить индекс каждого объекта вместе с подсчетом.

Джонатан, кажется, имеет лучшую идею, если он уточнит?

Было бы лучше просто посчитать, где вы находитесь в foreach, хотя, проще и более адаптируемо.

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

static class Extensions
{
    public static IEnumerable<(int, T)> Enumerate<T>(
        this IEnumerable<T> 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}");
        }
    }
}

Почему foreach ?!

Самый простой способ использования для вместо Еогеаспа , если вы используете список :

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

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

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

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

myList.indexOf(m)

int index;
foreach (Object o in collection)
{
    index = collection.indexOf(o);
}

Это будет работать для поддержки коллекций IList.

Это то, как я это делаю, что приятно из-за своей простоты / краткости, но если вы много делаете в теле цикла 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);
    ...
}

Ответ: лоббируйте языковую группу C # для прямой языковой поддержки.

Ведущий ответ гласит:

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

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

Команда разработчиков языка Microsoft C # может создать новую функцию языка C #, добавив поддержку нового интерфейса 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 ()используется и with var indexприсутствует, то компилятор ожидает, что коллекция элементов объявит IIndexedEnumerableинтерфейс. Если интерфейс отсутствует, компилятор может полифиллом обернуть исходный код объектом IndexedEnumerable, который добавляет код для отслеживания индекса.

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

Позже, CLR может быть обновлен, чтобы иметь внутреннее отслеживание индекса, которое используется, только если withуказано ключевое слово, а источник не реализует напрямуюIIndexedEnumerable

Почему:

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

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

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

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

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

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);
}

После добавления следующей структуры и метода расширения.

Метод struct и extension инкапсулирует функциональность Enumerable.Select.

public struct ValueWithIndex<T>
{
    public readonly T Value;
    public readonly int Index;

    public ValueWithIndex(T value, int index)
    {
        this.Value = value;
        this.Index = index;
    }

    public static ValueWithIndex<T> Create(T value, int index)
    {
        return new ValueWithIndex<T>(value, index);
    }
}

public static class ExtensionMethods
{
    public static IEnumerable<ValueWithIndex<T>> GetEnumeratorWithIndex<T>(this IEnumerable<T> enumerable)
    {
        return enumerable.Select(ValueWithIndex<T>.Create);
    }
}

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

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

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

var list = new List<int> { 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));

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

По сути, он пишет метод расширения, который оборачивает итерацию в класс «IteratedItem» (см. Ниже), предоставляя доступ к индексу, а также к элементу во время итерации.

public class IndexedItem<TModel> {
  public IndexedItem(int index, TModel item) {
    Index = index;
    Item = item;
  }

  public int Index { get; private set; }
  public TModel Item { get; private set; }
}

Однако, хотя это было бы хорошо в среде без Razor, если вы выполняете одну операцию (то есть ту, которая может быть предоставлена ​​как лямбда), это не будет надежной заменой синтаксиса for / foreach в контекстах без Razor. ,

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

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

Я построил это в 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);

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

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

Похоже, вам больше всего нравится делать одну из трех вещей:

1) Получение объекта из коллекции, но в этом случае он у вас уже есть.

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

3) Установка свойства для объекта в зависимости от его порядка в цикле ... хотя вы могли бы легко установить это при добавлении объекта в коллекцию.

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

Однако при работе с индексами единственным разумным ответом на проблему является использование цикла for. Все остальное вносит сложности в код, не говоря уже о сложности времени и пространства.

Как насчет этого? Обратите внимание, что myDelimitedString может быть нулевым, если 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;
}

У меня просто была эта проблема, но обдумывание проблемы в моем случае дало лучшее решение, не связанное с ожидаемым решением.

Это может быть довольно распространенным случаем, в основном, я читаю из одного списка источников и создаю объекты на их основе в списке адресатов, однако мне нужно сначала проверить, допустимы ли исходные элементы, и хочу вернуть строку любого ошибка. На первый взгляд, я хочу получить индекс в перечислителе объекта в свойстве Current, однако, поскольку я копирую эти элементы, я все равно неявно знаю текущий индекс из текущего места назначения. Очевидно, это зависит от вашего целевого объекта, но для меня это был список, и, скорее всего, он будет реализовывать ICollection.

т.е.

var destinationList = new List<someObject>();
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]});
  }
}

Я думаю, что это не всегда применимо, но достаточно часто, чтобы упоминать.

Во всяком случае, дело в том, что иногда в вашей логике уже есть неочевидное решение ...

Я не был уверен, что вы пытаетесь сделать с индексной информацией, основанной на вопросе. Однако в 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) в списке.