Ok aquí están mis conclusiones después de pasar por la salida Reflector por un tiempo. LINQ a objetos combinan los where
predicados consecutivos cuando se utiliza WhereArrayIterator
o WhereListIterator
haciendo que se comportan casi como & & operador, pero no tan exactamente:
Cuando se utilizan x.a==1 && x.b==1
la cláusula where se traduce en una Func<TSource, bool>
con este aspecto:
bool daspredicate(TSource x)
{
return x.a==1 && x.b==1
}
Sin embargo, cuando usa cláusulas Where consecutivas, hay una pequeña penalización de rendimiento, al menos desde IL-aspect no JITted.Así es como se ve el código después de combinar:
bool predicate1(TSource x)
{
return x.a==1;
}
bool predicate2(TSource x)
{
return x.b==1;
}
bool daspredicate(TSource x)
{
return predicate1(x) && predicate2(x);
}
Como puede ver, esto implica una sobrecarga de llamadas de funciones adicionales. Esto puede ser bastante caro a menos que JIT incorpore las funciones. Estoy seguro de que hace un buen trabajo, pero ahora sabemos que el trabajo de JIT se vuelve mucho más fácil si combinamos nuestras declaraciones Where, a menos que sea necesario.
En lo que respecta al lado SQL, las consultas son las mismas. Incluso antes de la ejecución, el depurador evalúa el objeto de consulta en la misma instrucción SQL. No podía ir demasiado lejos en el espacio de nombres de Linq porque las cosas parecían mucho más complejas, pero dado que las consultas son las mismas, no debería haber penalizaciones, a diferencia del ejemplo de LINQ-a-objetos anterior.
EDITAR: He visto instancias en las que múltiples sentencias where resultan en subconsultas anidadas en el servidor SQL. Creo que es mejor ceñirse a las declaraciones individuales donde sea posible para estar seguro.
casi duplicado de http://stackoverflow.com/questions/1648730/when-using-linq-what-is-the-difference-between-and-multiple-where-clauses –
No encontré eso en mi búsqueda, pero esto es LINQ-to-SQL específico de todos modos. –
el impacto en LINQ-to-Objects sería obvio, sin embargo, LINQ-to-SQL no está claro. –