C # foreach improvement?

Saya sering mengalami hal ini selama pemrograman di mana saya ingin memiliki loop count index di dalam foreach dan harus membuat integer, menggunakannya, increment, dll. Bukankah lebih baik jika ada kata kunci yang diperkenalkan yang jumlah loop di dalam foreach? Itu juga bisa digunakan dalam loop lain juga.

Apakah ini bertentangan dengan penggunaan kata kunci yang melihat bagaimana kompiler tidak akan mengizinkan kata kunci ini digunakan di mana pun kecuali dalam pembuatan loop?

Jika Anda membutuhkan jumlah loop di dalam foreachloop, mengapa Anda tidak menggunakan forloop biasa . The foreachLoop dimaksudkan untuk membuat penggunaan tertentu dari forloop sederhana. Sepertinya Anda memiliki situasi di mana kesederhanaan foreachtidak lagi bermanfaat.

Anda dapat menggunakan jenis anonim seperti ini

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

Ini mirip dengan enumeratefungsi Python

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

Saya hanya menambahkan jawaban Dan Finch di sini, seperti yang diminta.

Jangan beri aku poin, beri poin ke Dan Finch :-)

Solusinya adalah menulis metode ekstensi generik berikut:

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

Yang digunakan seperti ini:

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

Saya mungkin salah tentang hal ini, tetapi saya selalu berpikir bahwa titik utama dari foreach loop adalah untuk menyederhanakan iterasi dari hari STL dari C ++ yaitu

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

bandingkan ini dengan .NET penggunaan IEnumerable di muka

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

yang terakhir jauh lebih sederhana dan menghindari banyak perangkap lama. Selain itu, mereka tampaknya mengikuti aturan yang hampir identik. Misalnya Anda tidak dapat mengubah konten IEnumerable saat berada di dalam loop (yang jauh lebih masuk akal jika Anda menganggapnya sebagai cara STL). Namun, for loop seringkali memiliki tujuan logis yang berbeda dari iterasi.

Jika koleksi yang dimaksud adalah IList<T>, Anda cukup menggunakan fordengan pengindeksan:

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

Jika tidak, maka Anda bisa menggunakannya Select(), itu memiliki kelebihan yang memberi Anda indeks.

Jika itu juga tidak cocok, saya pikir mempertahankan indeks secara manual cukup sederhana, itu hanya dua baris kode yang sangat pendek. Membuat kata kunci khusus untuk ini akan menjadi kerja keras.

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

Jika yang Anda tahu adalah bahwa koleksi tersebut adalah jumlah IEn, tetapi perlu melacak berapa banyak elemen yang telah Anda proses sejauh ini (dan dengan demikian total ketika Anda selesai), Anda dapat menambahkan beberapa baris ke dasar untuk loop:

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
}

Anda juga bisa menambahkan variabel indeks yang ditambahkan ke foreach:

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

Jika Anda ingin membuat ini terlihat lebih elegan, Anda dapat menentukan satu atau dua metode ekstensi untuk "menyembunyikan" detail ini:

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

Pelingkupan juga berfungsi jika Anda ingin menjaga blok bersih dari tabrakan dengan nama lain ...

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

Untuk ini saya menggunakan whileloop. Loop dengan forjuga bekerja, dan banyak orang tampaknya lebih suka mereka, tetapi saya hanya suka menggunakan fordengan sesuatu yang akan memiliki jumlah iterasi yang tetap. IEnumerables dapat dihasilkan pada saat run time, jadi, menurut saya, whilelebih masuk akal. Sebut saja panduan pengodean informal, jika Anda mau.