The following code contains some of the most common mistakes I have been seeing when reviewing code that deals with enumerable objects.

public static IEnumerable<T> ElementsFromTheFirstWhichAreAlsoInTheSecond<T>(
    IEnumerable<T> enumerable1,
    IEnumerable<T> enumerable2
)
{
    var result = new List<T>();

    enumerable1.ToList().ForEach(a =>
    {
        if (enumerable2.Contains(a))
        {
            result.Add(a);
        }
    });

    return result;
}

Can you see what is wrong? Share in the comments.

More posts in ".NET Quiz" series:

8 Comments
  1. 1 – There is a List being created when calling ToList().
    2 – The Foreach is enumerating this list again.
    3 – There is a new list being returned.
    4 – This code is not using framework specific code for collections, that might get advantage of better way of dealingthis situation.
    5 – This can easily be replaced by: return first.Intersect(second);

      1. Interesting. As far as I understood, this method is returning objects that exist in both worlds.

        1. Here we go. This is the current underlying implementation of the Intersect function:

          private static IEnumerable<TSource> IntersectIterator<TSource>(
              IEnumerable<TSource> first, 
              IEnumerable<TSource> second, 
              IEqualityComparer<TSource> comparer
              )
          {
              Set<TSource> set = new Set<TSource>(comparer);
              foreach (TSource element in second)
              {
                  set.Add(element);
              }
          
              foreach (TSource element in first)
              {
                  if (set.Remove(element))
                  {
                      yield return element;
                  }
              }
          }
          

          Did you see the difference?

  2. For some reason a few developers like so much to write inline code. So, this pattern enumerable1.ToList().ForEach is very common. Problem is ToList will iterate all elements of enumerable in order to create a new object (more complex) List. Second problem is var result = new List(). The foreach will iterate all items of List and will add to result List object if condition is satisfied, so it could (and one day for sure will) explodes memory. Instead to add filtered item to a new object it should be yield returned, once the method returns IEnumerable. Last, regarding performance, if method handles large/complex data, a hashset will perform better to compare lists objects.

Leave a Reply

Your email address will not be published. Required fields are marked *