Wiederverwendung einer LINQ-Abfrage

Question

Es geht nicht um die Wiederverwendung eines Ergebnisses, sondern um die Anweisung selbst. Noch ist es über einen Fehler bei der Verwendung von var wie erwähnt in: LINQ to SQL: Reuse lambda expression

Aus reiner Neugier habe ich mich gefragt, ob es möglich ist, eine einzelne LINQ-Anweisung zu verwenden.

Lets sagen, dass ich die folgende LINQ-Anweisung haben:

.Where(x => x.Contains("")); 

Ist es möglich, die Anweisung x => x.Contains("") und verwenden eine Art von Hinweis auf diese für die spätere Verwendung in, extrahieren können sagen, eine andere Klasse?

So kann ich es nennen mag: .Where(previouslySavedStatement);

Answer 1

Sie es in einer Variablen speichern kann. Wenn Sie mit IQueryable arbeiten dann verwenden:

System.Linq.Expressions.Expression<Func<Foo, bool>> selector = x => x.Contains(""); 

Wenn Sie IEnumerable verwenden, dann verwenden:

Func<Foo, bool> selector = x => x.Contains(""); 

und verwenden Sie es in Ihrer Anfrage:

query.Where(selector); 

Answer 2

Es hängt davon ab. Es gibt zwei Methoden: Where, Enumerable.Where und Queryable.Where. Wenn Sie die .Where auf eine IEnumerable anwenden, als die erste aufgerufen wird, wenn Sie es auf eine IQueryable anwenden, wird die zweite aufgerufen.

Da Enumerable.Where eine Func einnimmt, ist es nicht wiederverwendbar. Da Queryable.Where einen Ausdruck einnimmt, ist es wiederverwendbar. Sie können dies tun, wie folgt:

var x = new List<string>().AsQueryable(); 

var query = x.Where (n => n.Contains("some string")); 

//Extract the lambda clause 
var expr = query.Expression; 
var methodExpr = (MethodCallExpression)expr; 
var quoteExpr = (UnaryExpression)methodExpr.Arguments[1]; 
var funcExpr = (Expression<Func<string, bool>>)quoteExpr.Operand; 

Sie können dann später erneut anwenden, die in dem Ausdruck:

var query2 = x.Where(funcExpr); 

Answer 3

Ja, können Sie eine Funktion, welche die Abfrage, die Sie wiederverwenden möchten schreiben, das dauert und ein IQueryable < T zurück >

public IQueryable<T> ContainsEmpty(IQueryable<T> query) 
    { 
     return query.Where(x => x.Contains("")); 
    } 

Jetzt können Sie es wiederverwenden:

query1 = ContainsEmpty(query1); 
    query2 = ContainsEmpty(another);