Como você obtém o índice da iteração atual de um loop foreach?

Existe alguma construção de linguagem rara que não encontrei (como as poucas que aprendi recentemente, algumas sobre Stack Overflow) em C # para obter um valor que representa a iteração atual de um loop foreach?

Por exemplo, atualmente faço algo assim, dependendo das circunstâncias:

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

O foreaché para iterar sobre coleções implementadas IEnumerable. Isso é feito chamando GetEnumeratora coleção, que retornará um Enumerator.

Este enumerador possui um método e uma propriedade:

• MoveNext ()
• Atual

Currentretorna o objeto em que o Enumerator está atualmente, MoveNextatualiza Currentpara o próximo objeto.

O conceito de um índice é estranho ao conceito de enumeração e não pode ser feito.

Por esse motivo, a maioria das coleções pode ser percorrida usando um indexador e a construção do loop for.

Eu prefiro usar um loop for nessa situação em comparação com o rastreamento do índice com uma variável local.

Ian Mercer postou uma solução semelhante a esta no blog de Phil Haack :

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

Isso fornece o item ( item.value) e seu índice ( item.i) usando essa sobrecarga de LINQsSelect :

o segundo parâmetro da função [inside Select] representa o índice do elemento de origem.

O new { i, value }está criando um novo objeto anônimo .

As alocações de heap podem ser evitadas usando ValueTuplese você estiver usando o C # 7.0 ou posterior:

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

Você também pode eliminar item.usando destruturação automática:

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

Finalmente, o C # 7 tem uma sintaxe decente para obter um índice dentro de um foreachloop (ou seja, tuplas):

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

Um pequeno método de extensão seria necessário:

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

Poderia fazer algo assim:

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

Discordo dos comentários de que um forloop é uma escolha melhor na maioria dos casos.

foreaché uma construção útil e não substituível por um forloop em todas as circunstâncias.

Por exemplo, se você tiver um DataReader e percorrer todos os registros usando um, foreachele automaticamente chama o método Dispose e fecha o leitor (que pode fechar a conexão automaticamente). Portanto, é mais seguro, pois evita vazamentos de conexão, mesmo que você esqueça de fechar o leitor.

(Claro que é uma boa prática sempre fechar os leitores, mas o compilador não será capaz de capturá-lo se você não o fizer - você não pode garantir que fechou todos os leitores, mas pode aumentar a probabilidade de não perder conexões obtendo o hábito de usar o foreach.)

Pode haver outros exemplos de chamadas implícitas do Disposemétodo sendo úteis.

Resposta literal - aviso, o desempenho pode não ser tão bom quanto usar um intpara rastrear o índice. Pelo menos é melhor do que usar IndexOf.

Você só precisa usar a sobrecarga de indexação de Select para agrupar cada item da coleção com um objeto anônimo que conhece o índice. Isso pode ser feito contra qualquer coisa que implemente 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);
}

Usando LINQ, C # 7 e o System.ValueTuplepacote NuGet, você pode fazer isso:

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

Você pode usar a foreachconstrução regular e poder acessar o valor e o índice diretamente, não como membro de um objeto, e mantém os dois campos apenas no escopo do loop. Por esses motivos, acredito que esta é a melhor solução se você puder usar o C # 7 e System.ValueTuple.

Usando a resposta do @ FlySwat, eu vim com esta solução:

//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
}

Você obtém o enumerador usando GetEnumeratore depois faz um loop usando um forloop. No entanto, o truque é criar a condição do loop listEnumerator.MoveNext() == true.

Como o MoveNextmétodo de um enumerador retorna true se houver um próximo elemento e ele puder ser acessado, a condição do loop fará com que o loop pare quando ficarmos sem elementos para iterar.

Não há nada errado em usar uma variável de contador. De fato, se você usa for, foreach whileou do, uma variável de contador deve em algum lugar ser declarada e incrementada.

Portanto, use esse idioma se não tiver certeza se possui uma coleção indexada adequadamente:

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

Caso contrário, use este caso você saiba que sua coleção indexável é O (1) para acesso ao índice (para o qual será Arraye provavelmente List<T>(a documentação não diz), mas não necessariamente para outros tipos (como 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'
}

Nunca deve ser necessário operar 'manualmente' IEnumerator, invocando MoveNext()e interrogando Current- foreachestá poupando esse incômodo em particular ... se você precisar pular itens, basta usar um continueno corpo do loop.

E, para ser completo, dependendo do que você estava fazendo com o seu índice (as construções acima oferecem bastante flexibilidade), você pode usar o 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));

Usamos AsParallel()acima, porque já estamos em 2014 e queremos fazer bom uso desses múltiplos núcleos para acelerar as coisas. Além disso, para o LINQ 'sequencial', você sóForEach()List<T>Array usa um método de extensão e ... e não está claro que usá-lo seja melhor do que fazer um simples foreach, pois você ainda está executando o thread único para obter uma sintaxe mais feia.

Você pode agrupar o enumerador original com outro que contenha as informações do índice.

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

Aqui está o código para a ForEachHelperclasse.

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

Aqui está uma solução que eu acabei de encontrar para esse problema

Código original:

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

Código atualizado

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

Método de extensão:

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

Basta adicionar seu próprio índice. Mantenha simples.

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

Só vai funcionar para uma lista e não para qualquer IEnumerable, mas no LINQ existe o seguinte:

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

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

Console.ReadLine();

@ Jonathan Eu não disse que era uma ótima resposta, apenas disse que estava apenas mostrando que era possível fazer o que ele pediu :)

@ Graphain Eu não esperaria que fosse rápido - não tenho muita certeza de como funciona, poderia reiterar a lista inteira a cada vez para encontrar um objeto correspondente, o que seria uma enorme quantidade de comparações.

Dito isto, a Lista pode manter um índice de cada objeto junto com a contagem.

Jonathan parece ter uma idéia melhor, se ele elaborar?

Seria melhor apenas manter uma contagem de onde você está na frente, mais simples e mais adaptável.

O C # 7 finalmente nos fornece uma maneira elegante de fazer isso:

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

Por que foreach ?!

A maneira mais simples é usar for em vez de foreach se você estiver usando a Lista :

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

Ou se você deseja usar foreach:

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

Você pode usar isso para conhecer o índice de cada loop:

myList.indexOf(m)

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

Isso funcionaria para o suporte a coleções IList.

É assim que eu faço, o que é bom por sua simplicidade / brevidade, mas se você estiver fazendo muito no corpo do loop obj.Value, ele envelhecerá rapidamente.

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

Esta resposta: solicite à equipe de idiomas C # o suporte direto ao idioma.

A resposta principal afirma:

Obviamente, o conceito de um índice é estranho ao conceito de enumeração e não pode ser feito.

Embora isso seja verdade na versão atual do idioma C # (2020), esse não é um limite conceitual de CLR / idioma, mas pode ser feito.

A equipe de desenvolvimento de linguagem C # da Microsoft poderia criar um novo recurso de linguagem C #, adicionando suporte para um novo Interface 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);
}

Se foreach ()for usado e with var indexestiver presente, o compilador espera que a coleção de itens declare IIndexedEnumerableinterface. Se a interface estiver ausente, o compilador pode preencher a origem com um objeto IndexedEnumerable, que adiciona o código para rastrear o índice.

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

Posteriormente, o CLR pode ser atualizado para ter um rastreamento de índice interno, usado apenas se a withpalavra-chave for especificada e a origem não implementar diretamenteIIndexedEnumerable

Por quê:

• O Foreach parece mais agradável e, em aplicativos de negócios, os loops de foreach raramente são um gargalo de desempenho
• O Foreach pode ser mais eficiente na memória. Ter um pipeline de funções em vez de converter para novas coleções a cada etapa. Quem se importa se usa mais alguns ciclos de CPU quando há menos falhas de cache da CPU e menos coletas de lixo?
• Exigir que o codificador adicione código de rastreamento de índice estraga a beleza
• É muito fácil de implementar (por favor, Microsoft) e é compatível com versões anteriores

Embora a maioria das pessoas aqui não seja funcionário da Microsoft, esta é uma resposta correta, você pode pressionar a Microsoft para adicionar esse recurso. Você já pode criar seu próprio iterador com uma função de extensão e usar tuplas , mas a Microsoft pode polvilhar o açúcar sintático para evitar a função de extensão.

Se a coleção for uma lista, você pode usar List.IndexOf, como em:

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

Melhor usar a continueconstrução segura de palavras-chave como esta

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

Você pode escrever seu loop assim:

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

Depois de adicionar o seguinte método struct e extensão.

O método struct e extension encapsula a funcionalidade 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);
    }
}

Minha solução para esse problema é um método de extensão WithIndex(),

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

Use-o como

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

Por interesse, Phil Haack acabou de escrever um exemplo disso no contexto de um Delegado de Navalha ( http://haacked.com/archive/2011/04/14/a-better-razor-foreach-loop.aspx )

Ele efetivamente escreve um método de extensão que envolve a iteração em uma classe "IteratedItem" (veja abaixo), permitindo o acesso ao índice e ao elemento durante a iteração.

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

No entanto, embora isso seja bom em um ambiente que não seja o Razor, se você estiver executando uma única operação (ou seja, uma que possa ser fornecida como um lambda), não será uma substituição sólida da sintaxe de for / foreach em contextos que não sejam do Razor .

Eu não acho que isso deva ser bastante eficiente, mas funciona:

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

Eu construí isso no 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.

Você também pode usar string.join:

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

Não acredito que haja uma maneira de obter o valor da iteração atual de um loop foreach. Contando a si mesmo, parece ser o melhor caminho.

Posso perguntar por que você gostaria de saber?

Parece que você provavelmente faria uma de três coisas:

1) Obtendo o objeto da coleção, mas neste caso você já o possui.

2) Contando os objetos para posterior processamento posterior ... as coleções têm uma propriedade Count que você pode usar.

3) Configurando uma propriedade no objeto com base em sua ordem no loop ... embora você possa configurá-lo facilmente ao adicionar o objeto à coleção.

A menos que sua coleção possa retornar o índice do objeto por algum método, a única maneira é usar um contador como no seu exemplo.

No entanto, ao trabalhar com índices, a única resposta razoável para o problema é usar um loop for. Qualquer outra coisa introduz a complexidade do código, sem mencionar a complexidade do tempo e do espaço.

Que tal algo como isso? Observe que myDelimitedString pode ser nulo se myEnumerable estiver vazio.

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

Acabei de ter esse problema, mas pensar no problema no meu caso deu a melhor solução, não relacionada à solução esperada.

Pode ser um caso bastante comum, basicamente, estou lendo de uma lista de fontes e criando objetos com base neles em uma lista de destinos. No entanto, tenho que verificar se os itens de origem são válidos primeiro e quero retornar a linha de qualquer erro. À primeira vista, desejo inserir o índice no enumerador do objeto na propriedade Current, no entanto, ao copiar esses elementos, conheço implicitamente o índice atual de qualquer maneira, a partir do destino atual. Obviamente, depende do seu objeto de destino, mas para mim era uma Lista e provavelmente implementará o ICollection.

ie

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

Nem sempre é aplicável, mas muitas vezes vale a pena mencionar, eu acho.

Enfim, o ponto é que, às vezes, já existe uma solução não óbvia na lógica que você tem ...

Eu não tinha certeza do que você estava tentando fazer com as informações do índice com base na pergunta. No entanto, em C #, geralmente você pode adaptar o método IEnumerable.Select para obter o índice do que desejar. Por exemplo, eu poderia usar algo assim para saber se um valor é ímpar ou par.

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

Isso daria a você um dicionário pelo nome, indicando se o item era ímpar (1) ou par (0) na lista.