Melhorias C # foreach?

Eu o encontro frequentemente durante a programação em que quero ter um índice de contagem de loop dentro de um foreach e preciso criar um número inteiro, usá-lo, incrementar etc. Não seria uma boa idéia se houvesse uma palavra-chave introduzida que fosse a contagem de loop dentro de um foreach? Também pode ser usado em outros loops.

Isso vai contra o uso de palavras-chave, visto que o compilador não permitiria que essa palavra-chave fosse usada em outro lugar, exceto em uma construção de loop?

Se você precisa de uma contagem de loop dentro de um foreachloop, por que não usa apenas um forloop regular ? O foreachloop foi projetado para forsimplificar o uso específico de loops. Parece que você tem uma situação em que a simplicidade foreachnão é mais benéfica.

Você pode usar tipos anônimos como este

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

Isso é semelhante à enumeratefunção do Python

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

Estou apenas adicionando a resposta de Dan Finch aqui, conforme solicitado.

Não me dê pontos, dê pontos para Dan Finch :-)

A solução é escrever o seguinte método de extensão genérico:

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

Que é usado assim:

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

Posso estar errado sobre isso, mas sempre achei que o ponto principal do loop foreach era simplificar a iteração dos dias STL do C ++, ou seja,

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

compare isso com o uso do .NET de IEnumerable no foreach

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

o último é muito mais simples e evita muitas das antigas armadilhas. Além disso, eles parecem seguir regras quase idênticas. Por exemplo, você não pode alterar o conteúdo IEnumerable enquanto estiver dentro do loop (o que faz muito mais sentido se você pensar na maneira STL). No entanto, o loop for geralmente tem um propósito lógico diferente da iteração.

Se a coleção em questão for uma IList<T>, você pode simplesmente usar forcom a indexação:

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

Caso contrário, você pode usar Select(), ele possui uma sobrecarga que fornece o índice.

Se isso também não é adequado, acho que manter esse índice manualmente é bastante simples, são apenas duas linhas muito curtas de código. Criar uma palavra-chave especificamente para isso seria um exagero.

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

Se tudo o que você sabe é que a coleção é um IEnumerable, mas precisa acompanhar quantos elementos você processou até o momento (e, portanto, o total quando terminar), você pode adicionar algumas linhas a um loop for básico:

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
}

Você também pode adicionar uma variável de índice incrementada a um foreach:

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

Se você deseja que isso pareça mais elegante, você pode definir um método de extensão ou dois para "ocultar" esses detalhes:

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

O escopo também funciona se você deseja manter o bloco limpo de colisões com outros nomes ...

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

Para isso eu uso um whileloop. Os loops fortambém funcionam, e muitas pessoas parecem preferi-los, mas eu só gosto de usar foralgo que terá um número fixo de iterações. IEnumerables podem ser gerados em tempo de execução, portanto, na minha opinião, whilefaz mais sentido. Chame de orientação informal de codificação, se quiser.