LINQ Aggregate special attention for last element of list

Question

I would like to pass in a different function to Aggregate for the last element in the collection.

A use for this would be:

List<string> listString = new List{"1", "2", "3"};
string joined = listString.Aggregate(new StringBuilder(), 
                                    (sb,s) => sb.Append(s).Append(", "), 
                                    (sb,s) => sb.Append(s)).ToString();

//joined => "1, 2, 3"

What would be a custom implementation if no other exists?

P.S. I would like to do this w/ composable functions iterating once through the collection. In other words, I do not want to do a Select wrapped in a String.Join

Answer 1

Aggregate does not allow that in natural way.

You can carry previous element and do you final handling after Aggregate. Also I think your best bet would be to write custom method that does that custom handling for last (and possibly first) element.

Some approximate code to special case last item with Aggregate (does not handle most special case like empty/short list):

var firstLast = seq.Aggregate(
  Tuple.Create(new StringBuilder(), default(string)),
  (sum, cur) => 
     {
       if (sum.Item2 != null)
       {
            sum.Item1.Append(",");
            sum.Item1.Append(sum.Item2);
       }
       return Tuple.Create(sum.Item1, cur);
     });
 firstLast.Item1.Append(SpecialProcessingForLast(sum.Item2));
 return firstLast.Item1.ToString();  

Aggregate with special case for "last". Sample is ready to copy/paste to LinqPad/console app, uncomment "this" when making extension function. Main shows aggregating array with summing all but last element, last one is subtracted from result:

void Main()
{
   Console.WriteLine(AggregateWithLast(new[] {1,1,1,-3}, 0, (s,c)=>s+c, (s,c)=>s-c));
   Console.WriteLine(AggregateWithLast(new[] {1,1,1,+3}, 0, (s,c)=>s+c, (s,c)=>s-c));
}

public static TAccumulate AggregateWithLast<TSource, TAccumulate>(
    /*this */ IEnumerable<TSource> source, 
    TAccumulate seed,
    Func<TAccumulate, TSource, TAccumulate> funcAll,
    Func<TAccumulate, TSource, TAccumulate> funcLast)
{
  using (IEnumerator<TSource> sourceIterator = source.GetEnumerator())
  {
    if (!sourceIterator.MoveNext())
    {
      return seed;
    }

    TSource last = sourceIterator.Current;
    TAccumulate total = seed;

    while (sourceIterator.MoveNext())
    {
      total = funcAll(total, last);
      last = sourceIterator.Current;
    }

    return funcLast(total, last);
  }
}

Note: if you need just String.Join than one in .Net 4.0+ takes IEnumerable<T> - so it will iterate sequence only once without need to ToList/ToArray.

Answer 2

Another approach for your particular example, is to skip the comma for the first element and prepend it to the tail elements, like this:

List<string> listString = new() { "1", "2", "3" };
string joined = listString
    .Select((value, index) => (value, index))
    .Aggregate(new StringBuilder(), (sb, s) =>
        s.index == 0
            ? sb.Append(s.value)
            : sb.Append(", ").Append(s.value))
    .ToString();

I know this does not address the question in the title, but for most "join things with some infix" problems, this works well. That is, when string.Join is not the solution.