Wie erhält man den Index der aktuellen Iteration einer foreach-Schleife?

Gibt es in C # ein seltenes Sprachkonstrukt, auf das ich nicht gestoßen bin (wie die wenigen, die ich kürzlich gelernt habe, einige über Stapelüberlauf), um einen Wert zu erhalten, der die aktuelle Iteration einer foreach-Schleife darstellt?

Zum Beispiel mache ich derzeit je nach den Umständen so etwas:

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

Das foreachdient zum Durchlaufen von implementierten Sammlungen IEnumerable. Dies geschieht durch Aufrufen GetEnumeratorder Sammlung, die eine zurückgibt Enumerator.

Dieser Enumerator hat eine Methode und eine Eigenschaft:

• MoveNext ()
• Aktuell

CurrentGibt das Objekt zurück, auf dem sich Enumerator gerade befindet, und wird auf das nächste Objekt MoveNextaktualisiert Current.

Das Konzept eines Index ist dem Konzept der Aufzählung fremd und kann nicht durchgeführt werden.

Aus diesem Grund können die meisten Sammlungen mit einem Indexer und dem for-Schleifenkonstrukt durchlaufen werden.

Ich bevorzuge in dieser Situation die Verwendung einer for-Schleife im Vergleich zur Verfolgung des Index mit einer lokalen Variablen.

Ian Mercer hat eine ähnliche Lösung wie diese auf Phil Haacks Blog veröffentlicht :

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

Dadurch erhalten Sie das Element ( item.value) und seinen Index ( item.i), indem Sie diese Überladung von LINQs verwendenSelect :

Der zweite Parameter der Funktion [inside Select] repräsentiert den Index des Quellelements.

Das new { i, value }erstellt ein neues anonymes Objekt .

Heap-Zuweisungen können vermieden werden, indem ValueTupleSie C # 7.0 oder höher verwenden:

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

Sie können das auch item.durch automatische Destrukturierung beseitigen :

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

Schließlich hat C # 7 eine anständige Syntax, um einen Index innerhalb einer foreachSchleife (dh Tupel) zu erhalten:

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

Eine kleine Erweiterungsmethode wäre erforderlich:

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

Könnte so etwas tun:

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

Ich bin mit Kommentaren nicht einverstanden, dass eine forSchleife in den meisten Fällen die bessere Wahl ist.

foreachist ein nützliches Konstrukt und kann nicht unter forallen Umständen durch eine Schleife ersetzt werden.

Wenn Sie beispielsweise einen DataReader haben und alle Datensätze mit einem durchlaufen, foreachruft er automatisch die Dispose- Methode auf und schließt den Reader (der dann die Verbindung automatisch schließen kann). Dies ist daher sicherer, da es Verbindungslecks verhindert, selbst wenn Sie vergessen, das Lesegerät zu schließen.

(Sicher, es ist eine gute Praxis, Leser immer zu schließen, aber der Compiler wird es nicht abfangen, wenn Sie dies nicht tun. Sie können nicht garantieren, dass Sie alle Leser geschlossen haben, aber Sie können es wahrscheinlicher machen, dass Sie keine Verbindungen verlieren, indem Sie abrufen in der Gewohnheit, foreach zu verwenden.)

Es kann andere Beispiele dafür geben, dass der implizite Aufruf der DisposeMethode nützlich ist.

Wörtliche Antwort - Warnung: Die Leistung ist möglicherweise nicht so gut wie die Verwendung von a intzur Verfolgung des Index. Zumindest ist es besser als zu benutzen IndexOf.

Sie müssen nur die Indexüberladung von Select verwenden, um jedes Element in der Sammlung mit einem anonymen Objekt zu versehen, das den Index kennt. Dies kann gegen alles erfolgen, was IEnumerable implementiert.

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

Mit LINQ, C # 7 und dem System.ValueTupleNuGet-Paket können Sie Folgendes tun:

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

Sie können das reguläre foreachKonstrukt verwenden und direkt auf den Wert und den Index zugreifen, nicht als Mitglied eines Objekts. Beide Felder bleiben nur im Bereich der Schleife. Aus diesen Gründen halte ich dies für die beste Lösung, wenn Sie C # 7 und verwenden können System.ValueTuple.

Mit der Antwort von @ FlySwat habe ich folgende Lösung gefunden:

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

Sie erhalten den Enumerator mit GetEnumeratorund dann eine Schleife mit einer forSchleife. Der Trick besteht jedoch darin, den Zustand der Schleife herzustellen listEnumerator.MoveNext() == true.

Da die MoveNextMethode eines Enumerators true zurückgibt, wenn es ein nächstes Element gibt und auf das zugegriffen werden kann, stoppt die Schleifenbedingung die Schleife, wenn uns die Elemente zum Durchlaufen ausgehen.

Es ist nichts Falsches daran, eine Zählervariable zu verwenden. In der Tat, ob Sie verwenden for, foreach whileoder domuss eine Zählvariable irgendwo deklariert und erhöht werden.

Verwenden Sie diese Redewendung, wenn Sie nicht sicher sind, ob Sie eine entsprechend indizierte Sammlung haben:

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

Verwenden Sie diese Option andernfalls, wenn Sie wissen, dass Ihre indizierbare Sammlung O (1) für den Indexzugriff ist (für die sie bestimmt ist Arrayund wahrscheinlich auch List<T>(in der Dokumentation nicht angegeben), jedoch nicht unbedingt für andere Typen (z. B. 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'
}

Es sollte niemals notwendig sein, das manuell IEnumeratordurch Aufrufen MoveNext()und Abfragen zu bedienen Current- foreachdas erspart Ihnen diese besondere Mühe ... Wenn Sie Elemente überspringen müssen, verwenden Sie einfach ein continueim Hauptteil der Schleife.

Und nur der Vollständigkeit halber, je nachdem , was Sie tun mit Ihrem Index (die obigen Konstrukte bieten viel Flexibilität), könnten Sie Parallel LINQ verwenden:

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

Wir verwenden AsParallel()oben, weil es bereits 2014 ist, und wir möchten diese mehreren Kerne gut nutzen, um die Dinge zu beschleunigen. Außerdem erhalten Sie für 'sequentielles' LINQ nur eine ForEach()Erweiterungsmethode für List<T>undArray ... und es ist nicht klar, dass die Verwendung besser ist als eine einfache foreach, da Sie immer noch Single-Threaded für eine hässlichere Syntax ausführen.

Sie können den ursprünglichen Enumerator mit einem anderen umschließen, der die Indexinformationen enthält.

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

Hier ist der Code für die ForEachHelperKlasse.

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

Hier ist eine Lösung, die ich gerade für dieses Problem gefunden habe

Originalcode:

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

Code aktualisiert

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

Verlängerungsmethode:

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

Fügen Sie einfach Ihren eigenen Index hinzu. Halte es einfach.

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

Es wird nur für eine Liste funktionieren und nicht für eine IEnumerable, aber in LINQ gibt es Folgendes:

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 Ich habe nicht gesagt, dass es eine großartige Antwort ist, ich habe nur gesagt, dass es nur zeigt, dass es möglich ist, das zu tun, was er gefragt hat :)

@Graphain Ich würde nicht erwarten, dass es schnell geht - ich bin mir nicht ganz sicher, wie es funktioniert. Es könnte jedes Mal die gesamte Liste durchgehen, um ein passendes Objekt zu finden, was eine Menge Vergleiche wäre.

Das heißt, List könnte einen Index jedes Objekts zusammen mit der Anzahl behalten.

Jonathan scheint eine bessere Idee zu haben, wenn er näher darauf eingehen würde?

Es wäre jedoch besser, nur zu zählen, wo Sie sich gerade befinden, einfacher und anpassungsfähiger.

C # 7 gibt uns endlich eine elegante Möglichkeit, dies zu tun:

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

Warum foreach ?!

Der einfachste Weg ist die Verwendung von for anstelle von foreach, wenn Sie List verwenden :

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

Oder wenn Sie foreach verwenden möchten:

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

Sie können dies verwenden, um den Index jeder Schleife zu kennen:

myList.indexOf(m)

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

Dies würde für unterstützende Sammlungen funktionieren IList.

So mache ich es, was für seine Einfachheit / Kürze gut ist, aber wenn Sie viel im Loop-Body tun obj.Value, wird es ziemlich schnell alt.

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

Diese Antwort: Setzen Sie sich beim C # -Sprachteam für direkte Sprachunterstützung ein.

Die führende Antwort lautet:

Offensichtlich ist das Konzept eines Index dem Konzept der Aufzählung fremd und kann nicht durchgeführt werden.

Dies gilt zwar für die aktuelle C # -Sprachenversion (2020), dies ist jedoch keine konzeptionelle CLR / Sprachbeschränkung, sondern kann durchgeführt werden.

Das Microsoft C # -Sprachenentwicklungsteam könnte eine neue C # -Sprachenfunktion erstellen, indem es die Unterstützung für eine neue Schnittstelle IIndexedEnumerable hinzufügt

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

Wenn foreach ()verwendet wird und with var indexvorhanden ist, erwartet der Compiler, dass die Elementauflistung die IIndexedEnumerableSchnittstelle deklariert . Wenn die Schnittstelle nicht vorhanden ist, kann der Compiler die Quelle mit einem IndexedEnumerable-Objekt umschließen, das den Code zum Verfolgen des Index hinzufügt.

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

Später kann die CLR aktualisiert werden, um eine interne Indexverfolgung zu erhalten, die nur verwendet wird, wenn ein withSchlüsselwort angegeben ist und die Quelle nicht direkt implementiert wirdIIndexedEnumerable

Warum:

• Foreach sieht besser aus, und in Geschäftsanwendungen sind Foreach-Schleifen selten ein Leistungsengpass
• Foreach kann im Speicher effizienter sein. Eine Pipeline von Funktionen haben, anstatt bei jedem Schritt in neue Sammlungen zu konvertieren. Wen interessiert es, wenn ein paar CPU-Zyklen mehr verwendet werden, wenn weniger CPU-Cache-Fehler und weniger Speicherbereinigungen vorliegen?
• Wenn der Codierer Index-Tracking-Code hinzufügen muss, wird die Schönheit beeinträchtigt
• Es ist recht einfach zu implementieren (bitte Microsoft) und abwärtskompatibel

Während die meisten Leute hier keine Microsoft-Mitarbeiter sind, ist dies eine richtige Antwort. Sie können sich bei Microsoft dafür einsetzen, eine solche Funktion hinzuzufügen. Sie könnten bereits einen eigenen Iterator mit einer Erweiterungsfunktion erstellen und Tupel verwenden , aber Microsoft könnte den syntaktischen Zucker streuen, um die Erweiterungsfunktion zu vermeiden

Wenn es sich bei der Sammlung um eine Liste handelt, können Sie List.IndexOf wie folgt verwenden:

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

Verwenden Sie besser eine schlüsselwortsichere continueKonstruktion wie diese

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

Sie können Ihre Schleife folgendermaßen schreiben:

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

Nach dem Hinzufügen der folgenden Struktur und Erweiterungsmethode.

Die Struktur- und Erweiterungsmethode kapselt die Enumerable.Select-Funktionalität.

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

Meine Lösung für dieses Problem ist eine Erweiterungsmethode WithIndex().

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

Verwenden Sie es wie

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

Aus Interesse hat Phil Haack gerade ein Beispiel dafür im Zusammenhang mit einem Delegierten mit Rasiermesser-Vorlage geschrieben ( http://haacked.com/archive/2011/04/14/a-better-razor-foreach-loop.aspx ).

Tatsächlich schreibt er eine Erweiterungsmethode, die die Iteration in eine "IteratedItem" -Klasse (siehe unten) einschließt, die den Zugriff auf den Index sowie das Element während der Iteration ermöglicht.

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

Obwohl dies in einer Nicht-Razor-Umgebung in Ordnung wäre, wenn Sie eine einzelne Operation ausführen (dh eine, die als Lambda bereitgestellt werden könnte), ist dies kein solider Ersatz für die for / foreach-Syntax in Nicht-Razor-Kontexten .

Ich denke nicht, dass dies ziemlich effizient sein sollte, aber es funktioniert:

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

Ich habe dies in LINQPad erstellt :

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.

Sie könnten auch einfach verwenden string.join:

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

Ich glaube nicht, dass es eine Möglichkeit gibt, den Wert der aktuellen Iteration einer foreach-Schleife zu ermitteln. Sich selbst zu zählen, scheint der beste Weg zu sein.

Darf ich fragen, warum Sie es wissen wollen?

Es scheint, dass Sie höchstwahrscheinlich eines von drei Dingen tun würden:

1) Das Objekt aus der Sammlung abrufen, aber in diesem Fall haben Sie es bereits.

2) Zählen der Objekte für die spätere Nachbearbeitung ... Die Sammlungen verfügen über eine Count-Eigenschaft, die Sie verwenden können.

3) Festlegen einer Eigenschaft für das Objekt basierend auf seiner Reihenfolge in der Schleife ... obwohl Sie dies leicht festlegen können, wenn Sie das Objekt zur Sammlung hinzufügen.

Wenn Ihre Sammlung den Index des Objekts nicht über eine Methode zurückgeben kann, besteht die einzige Möglichkeit darin, einen Zähler wie in Ihrem Beispiel zu verwenden.

Wenn Sie jedoch mit Indizes arbeiten, besteht die einzig vernünftige Antwort auf das Problem darin, eine for-Schleife zu verwenden. Alles andere führt zu einer Komplexität des Codes, ganz zu schweigen von der Komplexität von Zeit und Raum.

Wie wäre es mit so etwas? Beachten Sie, dass myDelimitedString möglicherweise null ist, wenn myEnumerable leer ist.

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

Ich hatte gerade dieses Problem, aber das Nachdenken über das Problem in meinem Fall ergab die beste Lösung, unabhängig von der erwarteten Lösung.

Es kann durchaus vorkommen, dass ich aus einer Quellliste lese und darauf basierende Objekte in einer Zielliste erstelle. Ich muss jedoch zuerst prüfen, ob die Quellelemente gültig sind, und die Zeile eines beliebigen Objekts zurückgeben Error. Auf den ersten Blick möchte ich den Index in den Enumerator des Objekts in der Current-Eigenschaft einfügen. Beim Kopieren dieser Elemente kenne ich den aktuellen Index jedoch implizit vom aktuellen Ziel. Natürlich hängt es von Ihrem Zielobjekt ab, aber für mich war es eine Liste, und höchstwahrscheinlich wird es ICollection implementieren.

dh

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

Nicht immer zutreffend, aber oft genug, um erwähnenswert zu sein, denke ich.

Der Punkt ist jedenfalls, dass es manchmal bereits eine nicht offensichtliche Lösung in der Logik gibt, die Sie haben ...

Ich war mir nicht sicher, was Sie mit den Indexinformationen basierend auf der Frage versuchen wollten. In C # können Sie jedoch normalerweise die IEnumerable.Select-Methode anpassen, um den Index aus dem gewünschten Wert herauszuholen. Zum Beispiel könnte ich so etwas verwenden, um festzustellen, ob ein Wert ungerade oder gerade ist.

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

Dies würde Ihnen ein Wörterbuch mit Namen geben, ob das Element in der Liste ungerade (1) oder gerade (0) war.