Die markierte Antwort wird es ein wenig ungenau.
Wie @Philippe sagte, wird die erste in übersetzt werden:
objectList.Where(o => o.value1 < 100).Where(o=> o.value2 > 10)
während der zweite in übersetzt wird:
objectList.Where(o => o.value1 < 100 && o.value2 > 10)
AberLinq
a hat wenig Optimierung für verkettete Where
Aufrufe.
Wenn Sie Linq's
Quellcode prüfen sehen Sie folgendes:
class WhereEnumerableIterator<TSource> : Iterator<TSource>
{
public override IEnumerable<TSource> Where(Func<TSource, bool> predicate)
{
return new WhereEnumerableIterator<TSource>(source,
CombinePredicates(this.predicate, predicate));
}
}
Was CombinePredicates
tut, ist, um die beiden Prädikate mit &&
zwischen ihnen kombiniert:
static Func<TSource, bool> CombinePredicates<TSource>(Func<TSource, bool> predicate1,
Func<TSource, bool> predicate2)
{
return x => predicate1(x) && predicate2(x);
}
So objectList.Where(X).Where(Y)
entspricht objectList.Where(X && Y)
abgesehen von der Erstellungszeit der Abfrage (die ohnehin extrem kurz ist) und dem Aufruf von zwei Prädikaten.
Unterm Strich ist, dass es nicht Filter oder die Sammlung zwei Mal durchlaufen - aber eine zusammengesetzte Zeit.
Eigentlich ist das ziemlich ungenau. Wenn Sie 'Linq's Quellen überprüfen, werden Sie sehen, dass' Where' eine Methode hat, die '.Where (x) .Where (y)' in '.Where (x && y)' übersetzt. [Quelle] (http://referencesource.microsoft.com/#System.Core/System/Linq/Enumerable.cs,f7e72dc9c9621f30) –
Guter Punkt, ich bin nicht in der Lage zu sagen, ob ich dies im Jahr 2009 überprüft oder wenn es war die ganze Zeit wahr. – Philippe