Using LINQ where (lamdaexp). First and first (lambdaexp)

I think your question is more like:

• Will Where
  
  iterate through the entire collection before switching to First
  
  ?
• Will it First
  
  do the same?

I wrote my own implementation in Where

and First

.
This example is not an 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);

      

        
        
        
      

    

Put a debugger breakpoint inside MyWhere

and MyFirst

foreach

and start understanding what happens when you work with iterators using Linq To Objects.

.Where()

Filters the collection based on expression, it will return a collection of type IEnumerable

, so here you can use it to search for products by name Foo

...

void Main()
{
    List<Product> Products = new List<Product>
    {
        new Product { ProductID = 1, Name = "Foo", Description = "Amazing Foo", Price = 99.99M },
        new Product { ProductID = 2, Name = "Foo", Description = "Not so good Foo", Price = 49.99M },
        new Product { ProductID = 3, Name = "Bar", Description = "Avg Bar", Price = 29.99M } 
    };

    IEnumerable<Product> foos = Products.Where (product => product.Name == "Foo");
}

public class Product
{
    public int ProductID { get; set; }
    public string Name { get; set; }
    public string Description { get; set; }
    public decimal Price { get; set; }
}

      

        
        
        
      

    

If we change this and use it First()

, we get a first instance

product that matches our request, it finds that first instance and completes the request. If it doesn't find a match, it will throw an exception.

Product foo = Products.First (product => product.Name == "Foo");

      

        
        
        
      

    

What you are doing is inefficient, the clause Where

will First

iterate over every item in the collection, however the clause will only iterate until it finds a match.

If you are using LINQ to query the database, then this is what the sentence Where

will translate to ...

-- Region Parameters
DECLARE @p0 NVarChar(1000) = 'Foo'
-- EndRegion
SELECT [t0].[ProductID], [t0].[Name], [t0].[Description], [t0].[Price]
FROM [Products] AS [t0]
WHERE [t0].[Name] = @p0

      

        
        
        
      

    

And this is what First

will be translated into ..

-- Region Parameters
DECLARE @p0 NVarChar(1000) = 'Foo'
-- EndRegion
SELECT TOP (1) [t0].[ProductID], [t0].[Name], [t0].[Description], [t0].[Price]
FROM [Products] AS [t0]
WHERE [t0].[Name] = @p0

      

        
        
        
      

    

When used, the .Where().First()

expression will not iterate over every item in the collection, instead it will just exit after the condition of the expression is metFirst()