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))

    return result;

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

This Post Has 8 Comments

  1. Flavio Canedo

    First já é um enumerador pq usar o tolist sem necessidade…

  2. Arley

    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. Elemar Júnior

      5 – Intersect does not do the very same thing.

      1. Arley Silva de Padua

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

        1. Elemar Júnior

          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)
              foreach (TSource element in first)
                  if (set.Remove(element))
                      yield return element;

          Did you see the difference?

  3. Arley Padua

    6 – The second collection is enumerated for every item on the first collection

  4. Thiago Borba

    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