Question

Take

        var query = Process.GetProcesses()
                            .OrderBy(p => p.WorkingSet64)
                            .ThenByDescending(p => p.Threads.Count);
                            .Where(p => p.ProcessName.Length < 9);

It works fine. Take

        var query = Process.GetProcesses()
                            .OrderBy(p => p.WorkingSet64)
                            .ThenByDescending(p => p.Threads.Count);
                            //.Where(p => p.ProcessName.Length < 9);

        query = query.Where(p => p.ProcessName.Length < 9);

This does not work. I do not understand why the first method works. In my mind these queries are the same. ThenByDescending returns IOrderedEnumerable<T> which is piped into Where(). The first method should not work because Where only works with IEnumerable<T>. Alas…it does work.

How does this processing pipeline function?

Answer 1

The difference is because of a misunderstanding of the var keyword and LINQ queries.

var (C# reference)

Using the var keyword is the same as specifying the same type as the right side of the assignment. It does not mean that you can assign any type to the variable.

In LINQ queries, most of the basic expressions return an IEnumerable, but it many cases, they do not return just an IEnumerable. Instead, they return an type that inherits from IEnumerable.

In this case, you are doing the equivalent of this:

IEnumerable<Process> query = Process.GetProcesses()
                            .OrderBy(p => p.WorkingSet64)
                            .ThenByDescending(p => p.Threads.Count);
                            .Where(p => p.ProcessName.Length < 9);

and

IOrderedEnumerable<Process> query = Process.GetProcesses()
                                    .OrderBy(p => p.WorkingSet64)
                                    .ThenByDescending(p => p.Threads.Count);

// Won't work because Where doesn't return an IOrderedEnumerable.
query = query.Where(p => p.ProcessName.Length < 9);

The reason that the first snippet works is because IOrderedEnumerable inherits from IEnumerable, so you can use it as such.

To fix the problem in the second example, you need to explicitly declare query as IEnumerable<Process>.