C # foreach miglioramenti?

Mi imbatto spesso in questo durante la programmazione in cui voglio avere un indice di conteggio dei cicli all'interno di un foreach e devo creare un numero intero, usarlo, incrementare, ecc. Non sarebbe una buona idea se ci fosse una parola chiave introdotta che era il conteggio dei loop all'interno di una foreach? Potrebbe essere utilizzato anche in altri loop.

Questo va contro l'uso delle parole chiave visto che il compilatore non permetterebbe che questa parola chiave venga usata da nessuna parte ma in un costrutto a ciclo?

Se hai bisogno di un conteggio dei loop all'interno di un foreachloop, perché non usi semplicemente un forloop normale . Il foreachloop aveva lo scopo di semplificare gli usi specifici dei forloop. Sembra che tu abbia una situazione in cui la semplicità del foreachnon è più vantaggiosa.

Puoi usare tipi anonimi come questo

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

Questo è simile alla enumeratefunzione di Python

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

Sto solo aggiungendo la risposta di Dan Finch qui, come richiesto.

Non darmi punti, dai punti a Dan Finch :-)

La soluzione è scrivere il seguente metodo di estensione generico:

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

Che viene utilizzato in questo modo:

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

Potrei sbagliarmi su questo, ma ho sempre pensato che il punto principale del ciclo foreach era semplificare l'iterazione dai giorni STL del C ++ cioè

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

confrontare questo con l'uso di .NET di IEnumerable nel foreach

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

quest'ultimo è molto più semplice ed evita molte delle vecchie insidie. Inoltre, sembrano seguire regole quasi identiche. Ad esempio, non è possibile modificare il contenuto di IEnumerable mentre si è all'interno del ciclo (il che ha molto più senso se lo si pensa in modo STL). Tuttavia, il ciclo for ha spesso uno scopo logico diverso dall'iterazione.

Se la raccolta in questione è una IList<T>, puoi semplicemente utilizzare forcon l'indicizzazione:

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

In caso contrario, è possibile utilizzare Select(), ha un sovraccarico che ti dà l'indice.

Se anche questo non è adatto, penso che mantenere quell'indice manualmente sia abbastanza semplice, sono solo due righe di codice molto brevi. La creazione di una parola chiave specifica per questo sarebbe eccessiva.

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

Se tutto ciò che sai è che la raccolta è un IEnumerable, ma devi tenere traccia di quanti elementi hai elaborato finora (e quindi il totale quando hai finito), puoi aggiungere un paio di righe a un ciclo for base:

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
}

Puoi anche aggiungere una variabile indice incrementata a un foreach:

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

Se vuoi rendere questo aspetto più elegante, puoi definire un metodo di estensione o due per "nascondere" questi dettagli:

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

Lo scoping funziona anche se vuoi mantenere il blocco pulito dalle collisioni con altri nomi ...

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

Per questo uso un whileloop. Anche i loop forfunzionano e molte persone sembrano preferirli, ma mi piace solo usare forqualcosa che avrà un numero fisso di iterazioni. IEnumerables può essere generato in fase di esecuzione, quindi, a mio avviso, whileha più senso. Chiamalo una linea guida di codifica informale, se vuoi.