Question

I have a function running over an enumerable, but the function should be a little bit different for the first item, for example:

void start() { 
    List<string> a = ...
    a.ForEach(DoWork);
}

bool isFirst = true;

private void DoWork(string s) {
   // do something

   if(isFirst)
     isFirst = false;
   else
     print("first stuff");

   // do something
}

How would you refactor this to avoid that ugly flag?

Answer 1

EDIT: added usage example, added a ForFirst method, reordered my paragraphs.

Below is a complete solution.

Usage is either of the following:

        list.ForFirst(DoWorkForFirst).ForRemainder(DoWork);
        // or 
        list.ForNext(1, DoWorkForFirst).ForRemainder(DoWork);

The crux is the ForNext method, which performs an action for the specified next set of items from the collection and returns the remaining items. I’ve also implemented a ForFirst method that simply calls ForNext with count: 1.

class Program
{
    static void Main(string[] args)
    {
        List<string> list = new List<string>();
        // ...

        list.ForNext(1, DoWorkForFirst).ForRemainder(DoWork);
    }

    static void DoWorkForFirst(string s)
    {
        // do work for first item
    }

    static void DoWork(string s)
    {
        // do work for remaining items
    }
}

public static class EnumerableExtensions
{
    public static IEnumerable<T> ForFirst<T>(this IEnumerable<T> enumerable, Action<T> action)
    {
        return enumerable.ForNext(1, action);
    }

    public static IEnumerable<T> ForNext<T>(this IEnumerable<T> enumerable, int count, Action<T> action)
    {
        if (enumerable == null)
            throw new ArgumentNullException("enumerable");

        using (var enumerator = enumerable.GetEnumerator())
        {
            // perform the action for the first <count> items of the collection
            while (count > 0)
            {
                if (!enumerator.MoveNext())
                    throw new ArgumentOutOfRangeException(string.Format(System.Globalization.CultureInfo.InvariantCulture, "Unexpected end of collection reached.  Expected {0} more items in the collection.", count));

                action(enumerator.Current);

                count--;
            }

            // return the remainder of the collection via an iterator
            while (enumerator.MoveNext())
            {
                yield return enumerator.Current;
            }
        }
    }

    public static void ForRemainder<T>(this IEnumerable<T> enumerable, Action<T> action)
    {
        if (enumerable == null)
            throw new ArgumentNullException("enumerable");

        foreach (var item in enumerable)
        {
            action(item);
        }
    }
}

I felt a bit ridiculous making the ForRemainder method; I could swear that I was re-implementing a built-in function with that, but it wasn’t coming to mind and I couldn’t find an equivalent after glancing around a bit. UPDATE: After reading the other answers, I see there apparently isn’t an equivalent built into Linq. I don’t feel so bad now.