foreach mit generischer Liste, Erkennung der ersten Iteration bei Verwendung des Werttyps

Question

Wenn foreach Wenn ich eine allgemeine Liste durcharbeite, möchte ich oft etwas anderes für das erste Element in der Liste tun:

List<object> objs = new List<object>
{
    new Object(),
    new Object(),
    new Object(),
    new Object()
};

foreach (object o in objs)
{
    if (o == objs.First())
    {
        System.Diagnostics.Debug.WriteLine("First object - do something special");
    }
    else
    {
        System.Diagnostics.Debug.WriteLine("object Do something else");
    }
}

Dies wird ausgegeben:

    First object - do something special
    object Do something else
    object Do something else
    object Do something else

Das ist alles schön und gut.

Wenn meine generische Liste jedoch vom Typ Wert ist, schlägt dieser Ansatz fehl.

List<int> ints = new List<int> { 0, 0, 0, 0 };
foreach (int i in ints)
{
    if (i == ints.First())
    {
        System.Diagnostics.Debug.WriteLine("First int - do something special");
    }
    else
    {
        System.Diagnostics.Debug.WriteLine("int Do something else");
    }
}

Dies wird ausgegeben:

    First int - do something special
    First int - do something special
    First int - do something special
    First int - do something special

Ich weiß, dass ich dies umprogrammieren könnte, um eine boolean Flaggenvariable oder traditionelle for Schleife, aber ich frage mich, ob es eine Möglichkeit gibt, herauszufinden, ob eine foreach-Schleife auf der ersten Iteration seiner Schleifenbildung ist.

Answer 1

Nun, man könnte es mit expliziter Iteration codieren:

using(var iter = ints.GetEnumerator()) {
  if(iter.MoveNext()) {
     // do "first" with iter.Current

     while(iter.MoveNext()) {
       // do something with the rest of the data with iter.Current
     }
  }
}

Die Option bool flag (mit foreach ) ist wahrscheinlich einfacher... das ist es, was ich (fast) immer mache!

Eine andere Möglichkeit wäre LINQ:

if(ints.Any()) {
  var first = ints.First();
  // do something with first
}

foreach(var item in ints.Skip(1)) {
  // do something with the rest of them
}

Der Nachteil des obigen Beispiels ist, dass es versucht, die Liste 3 Mal zu betrachten... da wir wissen, dass es eine Liste ist, ist das in Ordnung - aber wenn wir nur eine IEnumerable<T> wäre es sinnvoll, sie nur einmal zu wiederholen (da die Quelle möglicherweise nicht wieder lesbar ist).

Answer 2

Vor einiger Zeit schrieb ich SmartEnumerable (Teil von MiscUtil), das Ihnen mitteilt, ob das aktuelle Element das erste oder letzte ist, sowie seinen Index. Das könnte Ihnen helfen... es ist Teil von MiscUtil, das Open Source ist - Sie können nur SmartEnumerable unter der gleichen Lizenz nehmen, natürlich.

Beispielcode (c'n'p von der Webseite):

using System;
using System.Collections.Generic;

using MiscUtil.Collections;

class Example
{
    static void Main(string[] args)
    {
        List<string> list = new List<string>();
        list.Add("a");
        list.Add("b");
        list.Add("c");
        list.Add("d");
        list.Add("e");

        foreach (SmartEnumerable<string>.Entry entry in
                 new SmartEnumerable<string>(list))
        {
            Console.WriteLine ("{0,-7} {1} ({2}) {3}",
                               entry.IsLast  ? "Last ->" : "",
                               entry.Value,
                               entry.Index,
                               entry.IsFirst ? "<- First" : "");
        }
    }
}

EDIT: Beachten Sie, dass es zwar mit Referenztypen mit eindeutigen Referenzen funktioniert, aber dennoch fehlschlägt, wenn Sie eine Liste eingeben, in der die erste Referenz an anderer Stelle in der Liste auftaucht.

Answer 3

foreach(int i in ints.Take(1))
{
 //do first thing
}

foreach(int i in ints.Skip(1))
{
  //do other things
}

Answer 4

Da Sie bereits LINQ verwenden, können Sie dies tun:

var list = new List<Int32>();

// do something with list.First();

foreach (var item in list.Skip(1))
{
    // do other stuff
}

Answer 5

Das Problem, das Sie haben, liegt daran, dass die Gleichheit für Werttypen auf dem tatsächlichen Wert und nicht auf dem Verweis selbst basiert. Insbesondere in Ihrem Beispiel, Ihre Liste ist alle Nullen, so seine Frage, wenn currentItem == firstItem, und da sie beide Null sind, ist dies immer wahr. Für diese Art von Sache, ich habe immer gewickelt mit einem booleschen Flag.