Is there a way to know I am getting the last element in the foreach loop

Question

I need to do special treatment for the last element in the collection. I am wondering if I can know I hit the last element when using foreach loop.

Answer 1

There isn't a direct way. You'll have to keep buffering the next element.

IEnumerable<Foo> foos = ...

Foo prevFoo = default(Foo);
bool elementSeen = false;

foreach (Foo foo in foos)
{
    if (elementSeen) // If prevFoo is not the last item...
        ProcessNormalItem(prevFoo);

    elementSeen = true;
    prevFoo = foo;
}

if (elementSeen) // Required because foos might be empty.
    ProcessLastItem(prevFoo);

Alternatively, you could use the underlying enumerator to do the same thing:

using (var erator = foos.GetEnumerator())
{
    if (!erator.MoveNext())
        return;

    Foo current = erator.Current;

    while (erator.MoveNext())
    {
        ProcessNormalItem(current);
        current = erator.Current;
    }

    ProcessLastItem(current);
}

It's a lot easier when working with collections that reveal how many elements they have (typically the Count property from ICollection or ICollection<T>) - you can maintain a counter (alternatively, if the collection exposes an indexer, you could use a for-loop instead):

int numItemsSeen = 0;

foreach(Foo foo in foos)
{
   if(++numItemsSeen == foos.Count)
       ProcessLastItem(foo)

   else ProcessNormalItem(foo);
}

If you can use MoreLinq, it's easy:

foreach (var entry in foos.AsSmartEnumerable())
{
    if(entry.IsLast)
       ProcessLastItem(entry.Value)

    else ProcessNormalItem(entry.Value);
}

If efficiency isn't a concern, you could do:

Foo[] fooArray = foos.ToArray();

foreach(Foo foo in fooArray.Take(fooArray.Length - 1))
    ProcessNormalItem(foo);

ProcessLastItem(fooArray.Last());

Answer 2

List<int> numbers = new ....;
int last = numbers.Last();

Stack<int> stack = new ...;
stack.Peek();

update

    var numbers = new int[] { 1, 2,3,4,5 };

    var enumerator = numbers.GetEnumerator();
    object last = null;
    bool hasElement = true;

    do
    {
        hasElement = enumerator.MoveNext();

        if (hasElement)
        {
            last = enumerator.Current;
            Console.WriteLine(enumerator.Current);
        }
        else
            Console.WriteLine("Last = {0}", last);

    } while (hasElement);

    Console.ReadKey();

Answer 3

Is it Special treatment can be done only while processing on the foreach loop, Is it you can't do that while adding to the collection. If this is your case, have your own custom collection,

 public class ListCollection : List<string>
    {
        string _lastitem;

        public void Add(string item)
        {
            //TODO: Do  special treatment on the new Item, new item should be last one.
            //Not applicable for filter/sort
             base.Add(item);
        }
    }

Answer 4

Not without jumping through flaming hoops (see above). But you can just use the enumerator directly (slightly awkward because of C#'s enumerator design):

  IEnumerator<string> it = foo.GetEnumerator();
  for (bool hasNext = it.MoveNext(); hasNext; ) {
     string element = it.Current;
     hasNext = it.MoveNext();

     if (hasNext) { // normal processing
        Console.Out.WriteLine(element);
     } else { // special case processing for last element
        Console.Out.WriteLine("Last but not least, " + element);
     }
  }

Notes on the other approaches I see here: Mitch's approach requires having access to a container which exposes it's size. J.D.'s approach requires writing a method in advance, then doing your processing via a closure. Ani's approach spreads loop management all over the place. John K's approach involves creating numerous additional objects, or (second method) only allows additional post processing of the last element, rather than special case processing.

I don't understand why people don't use the Enumerator directly in a normal loop, as I've shown here. K.I.S.S.

This is cleaner with Java iterators, because their interface uses hasNext rather than MoveNext. You could easily write an extension method for IEnumerable that gave you Java-style iterators, but that's overkill unless you write this kind of loop a lot.

Answer 5

Deferred Execution trick

Build a class that encapsulates the values to be processed and the processing function for deferred execution purpose. We will end up using one instance of it for each element processed in the loop.

// functor class
class Runner {
    string ArgString {get;set;}
    object ArgContext {get;set;}

    // CTOR: encapsulate args and a context to run them in
    public Runner(string str, object context) {
        ArgString = str;
        ArgContext = context;
    }

    // This is the item processor logic. 
    public void Process() {
        // process ArgString normally in ArgContext
    }
}

Use your functor in the foreach loop to effect deferred execution by one element:

// intended to track previous item in the loop
var recent = default(Runner); // see Runner class above

// normal foreach iteration
foreach(var str in listStrings) {
    // is deferred because this executes recent item instead of current item
    if (recent != null)
        recent.Process(); // run recent processing (from previous iteration)

    // store the current item for next iteration
    recent = new Runner(str, context);
}

// now the final item remains unprocessed - you have a choice
if (want_to_process_normally)
    recent.Process(); // just like the others
else
    do_something_else_with(recent.ArgString, recent.ArgContext);

This functor approach uses memory more but prevents you from having to count the elements in advance. In some scenarios you might achieve a kind of efficiency.

• OR

Shorter Workaround

If you want to apply special processing to the last element after processing them all in a regular way ....

// example using strings
var recentStr = default(string);

foreach(var str in listStrings) {
    recentStr = str;
    // process str normally
}

// now apply additional special processing to recentStr (last)

It's a potential workaround.

Answer 6

Unfortunately not, I would write it with a for loop like:

string[] names = { "John", "Mary", "Stephanie", "David" };
int iLast = names.Length - 1;
for (int i = 0; i <= iLast; i++) {
    Debug.Write(names[i]);
    Debug.Write(i < iLast ? ", " : Environment.NewLine);
}

And yes, I know about String.Join :).

---

I see others already posted similar ideas while I was typing mine, but I'll post it anyway:

void Enumerate<T>(IEnumerable<T> items, Action<T, bool> action) {
    IEnumerator<T> enumerator = items.GetEnumerator();
    if (!enumerator.MoveNext()) return;
    bool foundNext;
    do {
        T item = enumerator.Current;
        foundNext = enumerator.MoveNext();
        action(item, !foundNext);
    }
    while (foundNext);
}

...

string[] names = { "John", "Mary", "Stephanie", "David" };
Enumerate(names, (name, isLast) => {
    Debug.Write(name);
    Debug.Write(!isLast ? ", " : Environment.NewLine);
})

Answer 7

Only way I know of is to increment a counter and compare with length on exit, or when breaking out of loop set a boolean flag, loopExitedEarly.