Bagaimana Anda mendapatkan indeks iterasi loop foreach saat ini?

Apakah ada beberapa konstruksi bahasa yang jarang saya temui (seperti beberapa yang saya pelajari baru-baru ini, beberapa di Stack Overflow) di C # untuk mendapatkan nilai yang mewakili iterasi saat ini dari foreach loop?

Misalnya, saya saat ini melakukan sesuatu seperti ini tergantung pada keadaan:

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

Ini foreachuntuk pengulangan koleksi yang mengimplementasikan IEnumerable. Ini melakukan ini dengan memanggil GetEnumeratorkoleksi, yang akan mengembalikan sebuahEnumerator .

Enumerator ini memiliki metode dan properti:

• MoveNext ()
• Arus

Currentmengembalikan objek tempat Enumerator aktif, MoveNextpembaruanCurrent ke objek berikutnya.

Konsep indeks adalah asing bagi konsep enumerasi, dan tidak dapat dilakukan.

Karena itu, sebagian besar koleksi dapat dilintasi menggunakan pengindeks dan konstruk for loop.

Saya sangat suka menggunakan for for dalam situasi ini dibandingkan dengan melacak indeks dengan variabel lokal.

Ian Mercer memposting solusi serupa dengan ini di blog Phil Haack :

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

Ini memberi Anda item ( item.value) dan indeksnya ( item.i) dengan menggunakan kelebihan LINQ iniSelect :

parameter kedua dari fungsi [di dalam Select] mewakili indeks elemen sumber.

Ini new { i, value }membuat objek anonim baru .

Alokasi tumpukan dapat dihindari dengan menggunakan ValueTuplejika Anda menggunakan C # 7.0 atau lebih baru:

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

Anda juga dapat menghilangkannya item.dengan menggunakan penghancuran otomatis:

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

Akhirnya C # 7 memiliki sintaks yang layak untuk mendapatkan indeks di dalam foreachloop (yaitu tuple):

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

Diperlukan sedikit metode penyuluhan:

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

Bisa melakukan sesuatu seperti ini:

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

Saya tidak setuju dengan komentar bahwa forloop adalah pilihan yang lebih baik dalam banyak kasus.

foreach adalah konstruk yang bermanfaat, dan bukan replaceble oleh a for loop dalam semua keadaan.

Misalnya, jika Anda memiliki DataReader dan loop melalui semua catatan menggunakan foreachitu secara otomatis memanggil Buang metode dan menutup pembaca (yang kemudian dapat menutup koneksi secara otomatis). Karenanya ini lebih aman karena mencegah kebocoran koneksi walaupun Anda lupa menutup pembaca.

(Tentu itu adalah praktik yang baik untuk selalu menutup pembaca tetapi kompiler tidak akan menangkapnya jika Anda tidak - Anda tidak dapat menjamin Anda telah menutup semua pembaca tetapi Anda dapat membuatnya lebih mungkin Anda tidak akan membocorkan koneksi dengan mendapatkan dalam kebiasaan menggunakan foreach.)

Mungkin ada contoh lain dari panggilan implisit dari Disposemetode yang bermanfaat.

Jawaban Literal - peringatan, kinerja mungkin tidak sebagus hanya menggunakan a intuntuk melacak indeks. Setidaknya lebih baik daripada menggunakan IndexOf.

Anda hanya perlu menggunakan indeks berlebihan untuk memilih untuk membungkus setiap item dalam koleksi dengan objek anonim yang mengetahui indeks. Ini dapat dilakukan terhadap apa pun yang mengimplementasikan 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);
}

Menggunakan LINQ, C # 7, dan System.ValueTuplepaket NuGet, Anda bisa melakukan ini:

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

Anda dapat menggunakan foreachkonstruk reguler dan dapat mengakses nilai dan indeks secara langsung, bukan sebagai anggota objek, dan membuat kedua bidang hanya dalam lingkup loop. Untuk alasan ini, saya percaya ini adalah solusi terbaik jika Anda dapat menggunakan C # 7 dan System.ValueTuple.

Menggunakan jawaban @ FlySwat, saya datang dengan solusi ini:

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

Anda mendapatkan enumerator menggunakan GetEnumeratordan kemudian Anda menggunakan forloop. Namun, triknya adalah membuat kondisi loop listEnumerator.MoveNext() == true.

Karena MoveNextmetode enumerator mengembalikan true jika ada elemen berikutnya dan itu dapat diakses, membuat kondisi loop membuat loop berhenti ketika kita kehabisan elemen untuk beralih.

Tidak ada yang salah dengan menggunakan variabel penghitung. Bahkan, apakah Anda menggunakan for, foreach whileatau do, variabel counter harus dideklarasikan dan ditingkatkan di suatu tempat.

Jadi gunakan idiom ini jika Anda tidak yakin apakah Anda memiliki koleksi yang diindeks sesuai:

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

Lain gunakan yang ini jika Anda tahu bahwa koleksi Anda yang dapat diindeks adalah O (1) untuk akses indeks (yang akan untuk Arraydan mungkin untuk List<T>(dokumentasi tidak mengatakan), tetapi tidak harus untuk jenis lain (seperti 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'
}

Seharusnya tidak perlu untuk 'secara manual' mengoperasikannya IEnumeratordengan memohon MoveNext()dan menginterogasi Current- foreachmenyelamatkan Anda dari gangguan khusus itu ... jika Anda perlu melewatkan item, cukup gunakan a continuedi badan loop.

Dan hanya untuk kelengkapan, tergantung pada apa yang Anda lakukan dengan indeks Anda (konstruksi di atas menawarkan banyak fleksibilitas), Anda dapat menggunakan LINQ Paralel:

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

Kami menggunakan di AsParallel()atas, karena ini sudah 2014, dan kami ingin memanfaatkan banyak inti untuk mempercepat. Lebih lanjut, untuk LINQ 'berurutan', Anda hanya mendapatkan ForEach()metode ekstensi List<T>danArray ... dan tidak jelas bahwa menggunakannya lebih baik daripada melakukan yang sederhana foreach, karena Anda masih menjalankan single-threaded untuk sintaks yang lebih buruk.

Anda dapat membungkus enumerator asli dengan enumerator lain yang berisi informasi indeks.

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

Ini adalah kode untuk ForEachHelperkelas.

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

Inilah solusi yang baru saja saya buat untuk masalah ini

Kode asli:

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

Kode yang diperbarui

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

Metode ekstensi:

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

Cukup tambahkan indeks Anda sendiri. Tetap sederhana.

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

Ini hanya akan berfungsi untuk Daftar dan bukan IEnumerable, tetapi di LINQ ada ini:

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 Saya tidak mengatakan itu adalah jawaban yang bagus, saya hanya mengatakan itu hanya menunjukkan itu mungkin untuk melakukan apa yang dia minta :)

@Graphain Saya tidak berharap ini akan cepat - Saya tidak sepenuhnya yakin cara kerjanya, itu bisa mengulangi seluruh daftar setiap kali untuk menemukan objek yang cocok, yang akan menjadi semacam perbandingan.

Yang mengatakan, Daftar mungkin menyimpan indeks dari setiap objek bersama dengan hitungan.

Jonathan tampaknya punya ide yang lebih baik, apakah dia mau menjelaskan?

Akan lebih baik untuk tetap menghitung sampai di mana Anda tahu, lebih sederhana, dan lebih mudah beradaptasi.

C # 7 akhirnya memberi kita cara yang elegan untuk melakukan ini:

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

Kenapa harus tahu dulu ?!

Cara termudah adalah menggunakan untuk bukannya foreach jika Anda menggunakan Daftar :

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

Atau jika Anda ingin menggunakan foreach:

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

Anda dapat menggunakan ini untuk mengetahui indeks setiap loop:

myList.indexOf(m)

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

Ini akan berfungsi untuk mendukung koleksi IList.

Ini adalah bagaimana saya melakukannya, yang bagus untuk kesederhanaan / singkatnya, tetapi jika Anda melakukan banyak hal dalam lingkaran obj.Value, itu akan menjadi tua dengan cepat.

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

Jawaban ini: melobi tim bahasa C # untuk dukungan bahasa langsung.

Jawaban terkemuka menyatakan:

Jelas, konsep indeks asing dengan konsep enumerasi, dan tidak dapat dilakukan.

Meskipun ini benar untuk versi bahasa C # saat ini (2020), ini bukan batas CLR / Bahasa konseptual, ini bisa dilakukan.

Tim pengembangan bahasa C # Microsoft dapat membuat fitur bahasa C # baru, dengan menambahkan dukungan untuk Interface baru 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);
}

Jika foreach ()digunakan dan with var indexada, maka kompiler mengharapkan koleksi item untuk menyatakan IIndexedEnumerableantarmuka. Jika antarmuka tidak ada, kompiler dapat polyfill membungkus sumber dengan objek IndexedEnumerable, yang menambahkan kode untuk melacak indeks.

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

Nantinya, CLR dapat diperbarui untuk memiliki pelacakan indeks internal, yang hanya digunakan jika withkata kunci ditentukan dan sumber tidak langsung menerapkanIIndexedEnumerable

Mengapa:

• Foreach terlihat lebih bagus, dan dalam aplikasi bisnis, foreach loop jarang menjadi hambatan kinerja
• Foreach dapat lebih efisien dalam hal memori. Memiliki pipeline fungsi alih-alih mengonversi ke koleksi baru di setiap langkah. Siapa yang peduli jika menggunakan lebih banyak siklus CPU ketika ada lebih sedikit kesalahan cache CPU dan lebih sedikit pengumpulan sampah?
• Mewajibkan pembuat kode untuk menambahkan kode pelacakan indeks, merusak keindahan
• Ini cukup mudah untuk diterapkan (harap Microsoft) dan kompatibel dengan versi sebelumnya

Sementara kebanyakan orang di sini tidak karyawan Microsoft, ini adalah sebuah jawaban yang benar, Anda dapat melobi Microsoft untuk menambahkan fitur tersebut. Anda sudah bisa membangun iterator Anda sendiri dengan fungsi ekstensi dan menggunakan tupel , tetapi Microsoft dapat menaburkan gula sintaksis untuk menghindari fungsi ekstensi

Jika koleksi adalah daftar, Anda dapat menggunakan List.IndexOf, seperti pada:

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

Lebih baik menggunakan continuekonstruksi kata kunci yang aman seperti ini

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

Anda dapat menulis loop seperti ini:

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

Setelah menambahkan struct dan metode ekstensi berikut.

Metode struct dan ekstensi merangkum fungsionalitas 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);
    }
}

Solusi saya untuk masalah ini adalah metode ekstensi WithIndex(),

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

Gunakan seperti

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

Yang menarik, Phil Haack baru saja menulis sebuah contoh tentang hal ini dalam konteks Delegasi Templated Razor ( http://haacked.com/archive/2011/04/14/a-better-razor-foreach-loop.aspx )

Secara efektif ia menulis metode ekstensi yang membungkus iterasi dalam kelas "IteratedItem" (lihat di bawah) yang memungkinkan akses ke indeks serta elemen selama iterasi.

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

Namun, sementara ini akan baik-baik saja di lingkungan non-Razor jika Anda melakukan operasi tunggal (yaitu operasi yang dapat disediakan sebagai lambda) itu tidak akan menjadi pengganti yang solid untuk sintaks for / foreach dalam konteks non-Razor .

Saya tidak berpikir ini seharusnya cukup efisien, tetapi berfungsi:

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

Saya membangun ini di 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.

Anda juga bisa menggunakan string.join:

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

Saya tidak percaya ada cara untuk mendapatkan nilai dari iterasi loop foreach saat ini. Menghitung diri sendiri, tampaknya menjadi cara terbaik.

Bolehkah saya bertanya, mengapa Anda ingin tahu?

Tampaknya Anda paling mungkin melakukan satu dari tiga hal:

1) Mendapatkan objek dari koleksi, tetapi dalam hal ini Anda sudah memilikinya.

2) Menghitung objek untuk pemrosesan pos nanti ... koleksi memiliki properti Count yang dapat Anda manfaatkan.

3) Mengatur properti pada objek berdasarkan urutannya dalam loop ... meskipun Anda dapat dengan mudah mengaturnya saat Anda menambahkan objek ke koleksi.

Kecuali koleksi Anda dapat mengembalikan indeks objek melalui beberapa metode, satu-satunya cara adalah menggunakan penghitung seperti pada contoh Anda.

Namun, ketika bekerja dengan indeks, satu-satunya jawaban yang masuk akal untuk masalah ini adalah menggunakan for for. Ada lagi yang memperkenalkan kompleksitas kode, belum lagi kompleksitas waktu dan ruang.

Bagaimana dengan sesuatu yang seperti ini? Perhatikan bahwa myDelimitedString mungkin nol jika myEnumerable kosong.

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

Saya baru saja mengalami masalah ini, tetapi memikirkan masalah dalam kasus saya memberikan solusi terbaik, tidak terkait dengan solusi yang diharapkan.

Ini bisa menjadi kasus yang cukup umum, pada dasarnya, saya membaca dari satu daftar sumber dan membuat objek berdasarkan pada mereka dalam daftar tujuan, namun, saya harus memeriksa apakah item sumber valid terlebih dahulu dan ingin mengembalikan baris dari sembarang kesalahan. Pada pandangan pertama, saya ingin memasukkan indeks ke enumerator objek di properti saat ini, namun, ketika saya menyalin elemen-elemen ini, saya secara implisit mengetahui indeks saat ini dari tujuan saat ini. Jelas itu tergantung pada objek tujuan Anda, tetapi bagi saya itu adalah Daftar, dan kemungkinan besar itu akan mengimplementasikan ICollection.

yaitu

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

Tidak selalu berlaku, tetapi sering cukup layak disebut, saya pikir.

Pokoknya, intinya adalah bahwa kadang-kadang ada solusi yang tidak jelas dalam logika yang Anda miliki ...

Saya tidak yakin apa yang Anda coba lakukan dengan informasi indeks berdasarkan pertanyaan. Namun, dalam C #, Anda biasanya dapat mengadaptasi metode IEnumerable.Select untuk mendapatkan indeks dari apa pun yang Anda inginkan. Misalnya, saya mungkin menggunakan sesuatu seperti ini untuk mengetahui apakah nilainya ganjil atau genap.

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

Ini akan memberi Anda kamus dengan nama apakah item itu aneh (1) atau genap (0) dalam daftar.