如何评估IEnumerable <T> 同时对C＃中的第一个和/或最后一个元素进行特殊处理？

Question

This is a more general form of the question, how can I do something special with the first and last element of a list? The more specific question is easy to answer. We know the index of the first and last element, so we can simply access them directly or test an index variable against those values. For example:

for (int i = 0; i < values.Count; ++i)
{
  if (i == values.Count - 1)
  {
    // do something with last element
  }
  else
  {
    // do something else
  }
}

But sometimes I need to do a variation of this with an IEnumerable<T> . For example:

public static Bar TransformFoo(Foo value)
{
  if (isLast /* how do we know this? */)
  {
    // do something with the last element
  }
  else
  {
    // do something else
  }    
}

public static IEnumerable<Bar> TransformFooSequence(IEnumerable<Foo> source)
{
  return source.Select(TransformFoo);
}

Since this is a common pattern, I'd like to solve it in a general way (rather than write a custom for loop for each case, as I have in the past). One option would be to convert the sequence to a list using ToList() or count the elements using Count() . The problem in both cases is that the solution involves evaluating the entire sequence, which can be prohibitively expensive.

So the question is, how can I evaluate an IEnumerable<T> sequence while giving special treatment to its first and/or last element while maintaining lazy evaluation of that sequence in a general way?

Answer 1

One way to solve this is to create a new extension method for IEnumerable<T> that returns the elements of the source sequence along with semantic information about their positions. If the elements of the source sequence have type T , then the extension method will return tuples of type (T, PositionFlags) . Here's the code:

[Flags]
enum PositionFlags
{
    None = 0,
    First = 1,
    Last = 2
}    

public static IEnumerable<(T value, PositionFlags flags)> WithPositions<T>(
    this IEnumerable<T> source)
{
    using (var enumerator = source.GetEnumerator())
    {
        if (!enumerator.MoveNext())
        {
            yield break;
        }

        T value = enumerator.Current;
        PositionFlags flags = PositionFlags.First;

        while (enumerator.MoveNext())
        {
            yield return (value, flags);

            value = enumerator.Current;
            flags = PositionFlags.None;
        }

        flags |= PositionFlags.Last;

        yield return (value, flags);
    }
}

We can then pass along the position information to give special treatment to the first and/or last item in a sequence. For example:

Bar TransformFoo(Foo value, bool isLast)
{
    if (isLast)
    {
        // do something with the last element
     }
    else
    {
        // do something else
    }     
}

IEnumerable<Bar> TransformFooSequence(IEnumerable<Foo> source)
{
  return source
      .WithPositions()
      .Select(entry => TransformFoo(
          entry.value,
          (entry.flags & PositionFlags.Last) == PositionFlags.Last));
}

Answer 2

There is an Enumerable.Select method that passes an element's index into the selector Func along with the element itself. You can pass the current index into the function along with the total items (or last index value) so that the function has the information required to handle the special items.

var source = {some IEnumerable<Foo>};
var count = source.Count();

source.Select( ( item, i ) => TransformFoo( item, i, count ) );

public static Bar TransformFoo( Foo item, int index, int totalItems )
{
    if( 0 == index )
    {
        // first item handling
    }
    else if( ( index + 1 ) == totalItems )
    {
        // last item handling
    }
    else
    {
        // default item handling
    }
}

Or calculate the first/last flags in the select expression:

source.Select( ( item, i ) => TransformFoo( item, i == 0, i == ( totalItems - 1 ) );

public static Bar TransformFoo( Foo item, bool isFirst, bool isLast )
...

Answer 3

An IEnumerable<> may be an unordered set. Properly designed, your function should require an IList<> to indicate that the input will be treated as an ordered set.

If for some reason you must expose the parameter as an IEnumerable<> , in 99% of cases you should simply convert it to a List<> for processing. Your team should be focusing on its core business rather than writing the most fancy code for little details like this one.

If you have landed in an amazingly rare situation where you must take an input parameter that is defined as an IEnumerable<> AND it is extremely costly to convert to a list, you can use the enumerator directly to get the elements and treat them any way you want.

This method will iterate a generic list and call first() , middle() , and last() on the element depending on its position.

public static bool DoSomething<T>(IEnumerable<T> source, Action<T> first, Action<T> middle, Action<T> last)
{
    T current = default(T);
    var enumerator = source.GetEnumerator();
    bool ok = enumerator.MoveNext();
    if (!ok) return false; //There were no elements
    var firstElement = enumerator.Current;
    ok = enumerator.MoveNext();
    if (!ok) return false; //There was only 1 element
    first(firstElement);
    while (ok)
    {
        current = enumerator.Current;
        ok = enumerator.MoveNext();
        if (ok) middle(current);
    }
    last(current);
    return true; 
}

Example calling it:

DoSomething
(
    myList,
    e => Console.WriteLine(string.Format("First: {0}", e)),  //This will run only for the first element
    e => Console.WriteLine(string.Format("Middle: {0}", e)), //This will be output several times
    e => Console.WriteLine(string.Format("Last: {0}", e))  //This will run only on the last element
);

This method handles any type and allows you to pass a delegate for each of the first, middle, and last elements. You didn't say how to handle the case if there aren't enough elements (you need three or more). In this example, if the set doesn't have enough elements to process in this fashion, none of them are processed, and the method returns false . Otherwise it returns true.

You can see it run with several test cases in my working example on DotNetFiddle

I would probably wrap this sort of logic in a class. For example, if you were writing a piece of code to process large flat files that had a header, detail, and footer section, maybe you'd write a base class like this, and inherit your file processors from it:

internal abstract class ReportBase
{
    protected readonly IEnumerable<string> _file;

    public ReportBase(IEnumerable<string> file)
    {
        _file = file;   
    }

    public bool Process()
    {
        return ProcessInternal(_file, ProcessHeader, ProcessDetail, ProcessFooter);
    }

    protected bool ProcessInternal<T>(IEnumerable<T> source, Action<T> first, Action<T> middle, Action<T> last)
    {
        T current = default(T);
        var enumerator = source.GetEnumerator();
        bool ok = enumerator.MoveNext();
        if (!ok) return false; //There were no elements
        var firstElement = enumerator.Current;
        ok = enumerator.MoveNext();
        if (!ok) return false; //There was only 1 element
        first(firstElement);
        while (ok)
        {
            current = enumerator.Current;
            ok = enumerator.MoveNext();
            if (ok) middle(current);
        }
        last(current);
        return true; //At l
    }

    abstract protected void ProcessHeader(string header);

    abstract protected void ProcessDetail(string header);

    abstract protected void ProcessFooter(string header);
}

On the other hand, you could avoid this whole mess if you asked the caller to pass you the elements separately, since it presumably knows which is which.

public void KeepItSimpleStupid<T>(T firstItem, IEnumerable<T> middleItems, T lastItem)
{
    firstItem.Foo();
    foreach (var item in middleItems) item.Bar();
    lastItem.Foo();
}

Answer 4

Alternative to handle the last element separately :

var last = source.Aggregate((previous, current) => {
    HandleNotLast(previous); 
    return current; }); 

HandleLast(last); 

There isn't easy way to handle both first and last separately using LINQ extensions. For that you will need enumerator. There are MoreLINQ extensions such as TagFirstLast , but most of them seem to get the count of elements before enumerating.

Answer 5

You wrote:

public static Bar TransformFoo(Foo value)
{
    if (isLast /* how do we know this? */)

You can't know this, because you didn't specify that Foo is always an object in a sequence

You could change the meaning of Foo into: a Foo is an object that ..., which is always a part of a sequence of Foos , in which case it would be expected that every Foo has functionality to get access to sequence that it belongs to.

class Foo
{
    ...
    IEnumerable<Foo> GetSequence(); // returns the sequence that this Foo belongs to
}

If you think it is quite normal for Foo objects not to be part of a sequence, than you should not add this function. Instead you should add functionality to the sequence of Foos .

Let's extend IEnumerable with a new LINQ function. See Extension Methods Demystified

public static IEnumerable<TResult> Transform<TSource, Tresult>(
   this IEnumerable<TSource> source,
   Func<TSource, TResult> transformFuncNonLastElement,
   Func<TSource, TResult> transformFuncLansElement)
{
     // for every element: check if it is the last one,
     // if not, yield return transformFuncNonLastElement
     // if last: yield return transformFuncLastElement
     IEnumerator<TSource> enumerator = source.GetEnumerator();

     if (enumerator.MoveNext())
     {   // There is at least one element.
         TSource current = enumerator.Current;

         // while current is not the last one: transformFuncNonLastElement
         while (enumerator.MoveNext())
         {
             // current is not the last one
             TResult transformedNonLastValue = transformFuncNonLastElement(current);
             yield return transformedNonLastValue;

             current = enumerator.Current;
         }

         // if here: there are no more elements. current is the last one
         TResult transformedLastValue = transformFuncLastElement(current);
         yield return transformedLastValue;
     }
     // else: input sequence empty: return empty
}

Usage:

IEnumerable<Foo> myFoos = ...
IEnumerable<Bar> result = myFoors.Transform(
   foo => ToNonLastBar(foo),
   foo => ToLastBar(foo));

Where:

Bar ToNonLastBar(Foo foo) {...}
Bar ToLastBar(Foo foo) {...}