C# Blog

Add context to IEnumerable<> elements

Elements of an IEnumerable sequence do not know about the other elements. I often need to compare an element with a previous or next element. Sometimes I need other context like all the other elements, the previous elements or if an element is the last element. That is why I use an extension method that adds context to all elements.

Examples

Imagine you have class like this:

      class President
      {
        public string Name { get; private set; }
        public int Salary { get; private set; }

        public President(string name, int salary)
        {
          Name = name;
          Salary = salary;
        }

        public override string ToString()
        {
          return string.Format("{0} - {1}", Name, Salary);
        }
      }
      

and a sequence like this:

      var presidents = new List<President>
      {
        new President( "Albert" , 100000),
        new President( "Bert" , 90000),
        new President( "Charly" , 105000),
        new President( "Dave" , 103000),
        new President( "Edward" , 104000),
        new President( "Fred" , 107000),
        new President( "Gilbert" , 110000),
        new President( "Henry" , 103000),
      };
      

Now you can add context:

      var presidentsWithContext = presidents.WithContext();
      

and use the context with LINQ.

      var presidentsEarnedMoreThanPreviousPresident = presidentsWithContext.Where(p => !p.IsFirst && p.Previous.Salary < p.Current.Salary);

      var presidentsEarnedMoreThanEverBefore = presidentsWithContext.Where(p => !p.IsFirst && p.Preceding.All(n => n.Salary < p.Current.Salary));

      var presidentsEarnedUniqueSalary = presidentsWithContext.Where(p => p.Other.All(b => b.Salary != p.Current.Salary));
      

This is the class with the extension method that I just called:

      /// <summary>
      /// Contains extension methods for adding context information to Enumerated Elements
      ///
      </summary>
      public static class ContextEnumerator
      {
      /// <summary>
        /// Creates a sequence providing the sequence context with each element
        ///
      </summary>
      /// <param name="source">The input sequence</param>
      /// <returns>An output sequence with information about the context of each element</returns>
        static public IEnumerable<ElementWithContext<T>> WithContext<T>(this IEnumerable<T>source)
        {
          if (source == null)
          {
            throw new ArgumentNullException("source");
          }
          using (var enumerator = source.GetEnumerator())
          {
            // move to the first element
            if (!enumerator.MoveNext())
            yield break;

            T previous = default(T);
            T current = enumerator.Current;
            var index = 0;

            // Continue from the seceond element
            while (enumerator.MoveNext())
            {
              T next = enumerator.Current;
              yield return new ElementWithContext<T>(previous, current, next,index, source, false);

              previous = current;
              current = next;
              index++;
            }

            // Return the last element
            yield return new ElementWithContext<T> (previous, current, default(T),index, source, true);
          }
        }


        public static IEnumerable<T> CurrentValues<T> (this IEnumerable<ElementWithContext<T>> elementsWithContext)
        {
          if (elementsWithContext == null)
          {
            throw new ArgumentNullException("elementsWithContext");
          }
          return elementsWithContext.Select(e => e.Current);
        }
      }
      

And this class provides the info of an element:

      /// <summary>
      /// Represents an Enumerated Element with additional properties about its context in the sequence
      ///
      </summary>
      public class ElementWithContext<T>
      {
        internal ElementWithContext(T previous, T current, T next, int index, IEnumerable<T> all, bool isLast)
        {
          Current = current;
          Previous = previous;
          Next = next;
          Index = index;
          All = all;
          IsLast = isLast;
        }

        /// <summary>All elements in the original order</summary>
        public IEnumerable<T> All { get; private set; }

        /// <summary>The element before the current element</summary>
        public T Previous { get; private set; }

        /// <summary>The current element</summary>
        public T Current { get; private set; }

        /// <summary>The element after the current element</summary>
        public T Next { get; private set; }

        /// <summary>The index of the current element</summary>
        public int Index { get; private set; }

        /// <summary>True if this is the first element</summary>
        public bool IsFirst { get { return Index == 0; } }

        /// <summary>True if this is the last element</summary>
        public bool IsLast { get; private set; }

        /// <summary>The elements before the current element</summary>
        public IEnumerable<T> Preceding { get { return All.Take(Index); } }

        /// <summary>The elements after the current element</summary>
        public IEnumerable<T> Following { get { return All.Skip(Index + 1); } }

        /// <summary>All elements except the current element</summary>
        public IEnumerable<T> Other { get { return Preceding.Concat(Following); } }

        public override string ToString()
        {
          if (Current == null)
          {
            return "Current is null.";
          }
          return Current.ToString();
        }
      }
      

As you can see, a lot of other properties are available like IsLast and Index.

Credits: Frank Bakker inspired me with an early version of this idea.

• LINQ
• Generics
• Extension methods
• 09-02-2015