+11  A: 

The first one will be translated into:

objectList.Where(o => o.value1 < 100).Where(o=> o.value2 > 10)

while the second one will be translated in:

objectList.Where(o => o.value1 < 100 && o.value2 > 10)

So, in the first one, you will have a first filtered sequence that is filtered again (first sequence contains all the objects with value < 100, the second one containing all the objects with value > 10 from the first sequence), in while the second one you will do the same comparisons in the same labda expression. This is valid fro Linq to objects, for other providers it depends how the expression is translated.

Philippe
A: 

At the most basic level, you get two Where operations instead of one. Using Reflector is the best way to examine what comes out the other end of a quesy expression.

Whether they get optimised down to the same thing depends on the actual LINQ provider - it needs to take the entire tree and convert it to another syntax. For LINQ To Objects, it doesnt.

C# in Depth is good to give you an understanding of this topic.

Ruben Bartelink
+4  A: 

The first one translates to :

objectList.Where(o => o.value1 < 100)
       .Where(o => o.value2 > 10);

while the latter gets you:

objectList.Where(o => o.value1 < 100 && o.value2 > 10);

It's functionnaly the same, and while the second one would spare a method call, the difference in performance is negligible. Use what's more readable for you.

That is, if you're using linq to objects. If you're using a provider, it depends on how it's implemented (if the predicate is not factored in the resulting query, the result can be sub-optimal).

Yann Schwartz
I actually typed it directly. You're right, the identity selector does not make sense.
Yann Schwartz
A: 

How about this for an answer: with && you can't guarantee that both expressions with be evaluated (if the first condition is false then the second might not be evaluated). With the two where clauses then you can. No idea whether it's true but it sounds good to me!

Nestor
I don't think that's true. If it's Linq to Objects, the first Where-call will return an enumeration only containing the items where condition 1 is true. So condition 2 will only be called for these items.
nikie
Philippe
A: 

All other things being equal, I would choose the condition1 && condition2 version, for the sake of code readability.

Konamiman
+1  A: 

I've just profile it. No difference in SQL code

sh1ng
Assuming the OP was talking about LINQ to SQL. =)
J. Steen