using LINQ where(lamdaexp).First and First(lambdaexp)

Question

Is there any difference in the below two approaches? I am getting same output but I am trying to understand which is right and effective

approach 1:

Product product12 = products.Where(p => p.ProductID == 12).First();

approach 2:

Product prod12 = products.First(p => p.ProductID == 12);

Answer 1

(I assume that you are using Linq to .Net)
Firstly let's look at their source codes:

Here is Where():

public static IEnumerable<TSource> Where<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
{
    if (source == null) 
        throw Error.ArgumentNull("source");
    if (predicate == null) 
        throw Error.ArgumentNull("predicate");
    if (source is Iterator<TSource>) 
        return ((Iterator<TSource>)source).Where(predicate);
    if (source is TSource[]) 
        return new WhereArrayIterator<TSource>((TSource[])source, predicate);
    if (source is List<TSource>) 
        return new WhereListIterator<TSource>((List<TSource>)source, predicate);
    return new WhereEnumerableIterator<TSource>(source, predicate);
}

And here is First()

   public static TSource First<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate) {
            if (source == null) throw Error.ArgumentNull("source");
            if (predicate == null) throw Error.ArgumentNull("predicate");
            foreach (TSource element in source) {
                if (predicate(element)) return element;
            }
            throw Error.NoMatch();
        }

And let's find what does each code do:

1. products.First(p => p.ProductID == 12);

Based on source code of the First() we can say, First() will iterate over collection, and will stop iteration when it finds first item in a collection which mets the criteria.

2. products.Where(p => p.ProductID == 12).First();

First it will create iterator in Where method where elements meet the criteria. Then, again it will add get the first elemnt to that iterator. And, again will returm the first element as soon as it finds it.

As an additional note, LINQ uses deferred execution in some methods. And it has some relationship with the result of your question.

Deferred execution is a pattern of the execution model by which the CLR ensures a value will be extracted only when it is required from the IEnumerable-based information source. When any Linq operator uses the deferred execution, the CLR encapsulates the related information, such as the original sequence, predicate, or selector (if any), into an iterator, which will be used when the information is extracted from the original sequence using ToList method or ForEachmethod or manually using the underlying GetEnumerator and MoveNext methods in C#.

And, the question is. Which one is faster?

---

The main point is that, Where().First is quicker than First. in case of List and Array. Otherwise, First() will be faster. Here is the detailed exlpanation in @Akash Kava answer.

Let's pay an attention to Where() implementation. It will return WhereListIterator() if your collection is List, but First() will just iterate over source. And in my opinion they have made some speed up in the implementation of WhereListIterator. And after this we are calling First() method which takes no predicate as input and only will iterate on filtered collection.

Also, as I understand, The Where iterator avoids indirect virtual table call, but calls iterator methods directly. And, this is the reason of this speed-up.

Answer 2

I just ran a test, you can see results here on .Net fiddle, https://dotnetfiddle.net/3lCqsR

True answer is, which is faster depends on the type of filter that is applied and the type of collection that is iterated over.

    Func<Item,bool> filter = x => x.Size == 200;

    Run("First", () => items.First( filter ));
    Run("Where First", () => items.Where( filter ).First());

88 milliseconds for First
69 milliseconds for Where First


    filter = x => x.Size < 200;

    Run("First", () => items.First( filter ));
    Run("Where First", () => items.Where( filter ).First());

2 milliseconds for First
4 milliseconds for Where First


    filter = x => x.Size > 200;

    Run("First", () => items.First( filter ));
    Run("Where First", () => items.Where( filter ).First());

88 milliseconds for First
71 milliseconds for Where First

So there is no definite answer.

Another test, https://dotnetfiddle.net/k11nX6 , all the time, First is faster than Where First.

UPDATE

After analyzing List class, it is found that Where().First() is only faster than First(), in case of List and Array only, it does not apply to IQueryable or any other form of Enumerable. The reason is, Enumerator used in List is not cached per thread. List always creates new Enumerator, so First() uses List's Enumerator (iterator).

WhereListIterator used in Where() for List, does not create new Enumerator, instead it caches current Iterator in thread. This makes Where().First() run faster.

However, this operation of caching WhereListIterator has some cost, so for smaller collection and some conditions that yield smaller results, Where().First() is slower.

If you look at this example, First beats Where First everytime.

https://dotnetfiddle.net/OrUUSG

Answer 3

They are functionally equivalent and equally effective. LINQ builds a query which is not evaluated until the result is enumerated, e.g. a foreach loop or in this case the First() operation.

So both will evaluate the items in the original order until it finds the first instance with ProductID == 12 and returns that instance if found (and throws an exception if not).

That said the latter approach is my preferred method as it is more succinct and, generally, easier to read.

Answer 4

I think your question is more like:

1. Will Where iterate the whole collection before getting to First?
2. Will First do the same as well?

I've written my own implementation to Where and First.
This example isn't the exact .net implementation, but it works in the same concept.

public static class Extensions
{
    public static IEnumerable<T> MyWhere<T>(this IEnumerable<T> collection, Func<T,bool> condition)
    {
        foreach(var item in collection)
        {
            if(condition(item))
            {
                yield return item;
            }
        }
    }

    public static T MyFirst<T>(this IEnumerable<T> collection, Func<T,bool> condition)
    {
        foreach (var item in collection)
        {
            if (condition(item))
            {
                return item;
            }
        }

        throw new InvalidOperationException("No element found");
    }
}

Execute this code:

List<int> myList = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
var five = myList.MyWhere(i => i < 6).MyFirst(i => i == 5);

Place a debugger breakpoint inside the MyWhere and MyFirst foreach and start understanding what happens when you work with iterators using Linq To Objects.