What is actually happening with IQueryable.Where()?

Question

This is is returning a boolean based on whether or not there are some matching IDs.

from t in getAll
select new Result
{
...             
    bool DetailsAvailable = 
        (db.SaveTrackings.Where(s => s.BundleID == t.bundleID 
                                  && s.UserID == t.userID)
                         .Count() > 0) ? true : false;
}

This is what I think understand: .Where() is returning all the entries with the matching IDs and then the .Count() is just seeing how many are there. I only feel like I half understand what we need s for.

I know what to expect from this code since it's been in use I just don't understand how it works and some of the documentation from MSDN is using some terminology that is confusing me.

All lambda expressions use the lambda operator =>, which is read as "goes to". The left side of the lambda operator specifies the input parameters (if any) and the right side holds the expression or statement block. The lambda expression x => x * x is read "x goes to x times x."

So how am I suppose to understand what my code means based on this, .Where(s "goes to" s.BundleID == t.BundleID...) so what's happening here? What does "goes to" mean? Is it comparing every ID in s to everyone one available in t? How do I understand why it's called "goes to" and what exactly is happening?

And then it gets more confusing...

The => operator has the same precedence as assignment (=) and is right-associative.

Lambdas are used in method-based LINQ queries as arguments to standard query operator methods such as Where.

When you use method-based syntax to call the Where method in the Enumerable class (as you do in LINQ to Objects and LINQ to XML) the parameter is a delegate type System.Func. A lambda expression is the most convenient way to create that delegate.

What is a delegate type System.Func<T, TResult> and how is it created with this "goes to" operator?

I can't just use code because I know that it's working, I need to understand how/why.

Answer 1

If it helps, think of s as a variable of type SaveTracking. It's iterating over each s in your collection/table, and testing the value of its BundleID.

The t is same idea - it's like it's iterating through all the return collection from the getAll.

It's like the SQL pseudocode:

 SELECT * FROM SaveTracking INNER JOIN GetAll 
    ON BundleID AND UserID

For a deeper technical description of what's going on with lambda expressions, check out Jon Skeet's book C# In Depth. Chapter 9 , p 230. I found this book very helpful.

Answer 2

Lambda expressions are just a way to shorten the code but it does exactly the same things as declaring a method that corresponds to the delegate type System.Func<T, TResult>

I believe that C# converts your lamba to a method in the background when you compile and it looks like this :

bool LambdaExpression(YourType s)
{
   return  s.BundleID == t.bundleID && s.UserID == t.userID;
}

Answer 3

Maybe it would help to see this function implemented by hand:

using System;
using System.Collections.Generic;

namespace CSharpSandbox
{
    class Program
    {
        static IEnumerable<T> Where<T>(IEnumerable<T> input, Func<T, bool> predicate)
        {
            foreach (T item in input)
            {
                if (predicate(item))
                    yield return item;
            }
        }

        static void Main(string[] args)
        {
            int[] numbers = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
            IEnumerable<int> evens = Where(numbers, n => n % 2 == 0);
            foreach (int even in evens)
            {
                Console.WriteLine(even);
            }
        }
    }
}

The construct name => someEvaluation creates an anonymous function consisting of the following parts:

• name is simply the name of a parameter, its type is inferred from its usage. You need a name so you can refer to the argument passed in the function.
• => is the start of your anonymous functions body, the scope of the body is a single expression.
• someEvaluation is the body of your anonymous function composed of a single expression.

In our case, Func<T, bool> defines a function which takes a single parameter of type T and returns an output of type bool. (If we had used Func<T, U, bool>, we'd take two inputs of type T and U and return a bool. The last type parameter in the Func definition is the return value.)

You can invoke an instance of Func exactly as you invoke any other function. If the func takes params, you pass them in as expected, your parameters are bound to the variable names you defined. When you invoke the function, control flow will jump inside your function and evaluate its results.

In principle, you don't need to create a Func anonymously. You can pass in any function which has a compatible type signature, such as:

    static bool IsEven(int n)
    {
        return n % 2 == 0;
    }

    static void Main(string[] args)
    {
        int[] numbers = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
        IEnumerable<int> evens = Where(numbers, IsEven);
        foreach (int even in evens)
        {
            Console.WriteLine(even);
        }
    }

This program produces the same output. In fact, behind the scenes, the syntax name => expression is syntax sugar; when it gets compiled, C# will produce a produce a private function with a hidden name and convert it to the format above.