Question: Let's say you have parameters(s) in your LINQ query where clause, how do you handle that?

Here is an example:

```
var peoples= from i in individuals
  where (string.IsNullOrEmpty(lastName) i.LastName.Equals(lastName))
  select i;

```

Answer: 
Try to understand what's going on under the hood:

* How query expressions are translated by the compiler
* How LINQ to Objects streams its data, and how it defers execution
* How queries execute remotely via IQueryable and expression trees

It's also worth becoming comfortable with both query expressions, e.g.

```
var query = from person in people
            where person.IsAdult
            select person.Name;

```

and "dot notation":

```
var query = people.Where(person => person.IsAdult)
                  .Select(person => person.Name);

```

Knowing both will let you choose the most readable form for any particular query.
The result of a query expression is *a query object*, not *the results of the query*. If you want the results, you can ask the query object to start proffering up results. That is, when you say:

```
var names = from c in customers where c.City == "London" select c.Name;

```

then names is *a query object* that represents "get me the names of all the customers in London". It is *not* a sequence in memory of all the names of customers who live in London; the results of the query are computed on-demand. It is not until you say:

```
foreach(var name in names) ...

```

that the actual results are computed.

This means that if you ask the same query object for its results twice, the answer might be different. The customers list might have been changed between the first time you ask and the second time you ask. Because queries defer getting their results, you always get fresh results. But you sometimes do the same work twice.