擴充套件表示式

老外寫的一個不錯的擴充套件表示式的文章，原文地址:

Dynamically Composing Expression Predicates

Suppose you wanted to write a LINQ to SQL query that implemented a keyword-style. search. In other words, a query that returned rows whose description contained some or all of a given set of keywords.

We could proceed as follows:

[object Object]IQueryable SearchProducts (params string[] keywords)
[object Object][object Object]

The temporary variable in the loop is required to avoid the outer variable trap, where the same variable is captured for each iteration of the foreach loop.

So far, so good. But this only handles the case where you want to match all of the specified keywords. Suppose instead, we wanted products whose description contains any of the supplied keywords. Our previous approach of chaining Where operators is completely useless! We could instead chain Union operators, but this would be inefficient. The ideal approach is to dynamically construct a lambda expression tree that performs an or-based predicate.

Of all the things that will drive you to manually constructing expression trees, the need for dynamic predicates is the most common in a typical business application. Fortunately, it’s possible to write a set of simple and reusable extension methods that radically simplify this task. This is the role of our PredicateBuilder class.

Using PredicateBuilder

Here's how to solve the preceding example with PredicateBuilder:

 [object Object]IQueryable SearchProducts (params string[] keywords)
[object Object][object Object]

PredicateBuilder Source Code

Here's the complete source:

using System;
using System.Linq;
using System.Linq.Expressions;
using System.Collections.Generic;
 
public static class PredicateBuilder
...{
  public static Expression> True ()  ...{ return f => true;  }
  public static Expression> False () ...{ return f => false; }
 
  public static Expression> Or (this Expression> expr1,
                                                      Expression> expr2)
  ...{
    var invokedExpr = Expression.Invoke (expr2, expr1.Parameters.Cast ());
    return Expression.Lambda>
          (Expression.Or (expr1.Body, invokedExpr), expr1.Parameters);
  }
 
  public static Expression> And (this Expression> expr1,
                                                       Expression> expr2)
  ...{
    var invokedExpr = Expression.Invoke (expr2, expr1.Parameters.Cast ());
    return Expression.Lambda>
          (Expression.And (expr1.Body, invokedExpr), expr1.Parameters);
  }
}

 

PredicateBuilder is also shipped as part of LINQKit, a productivity kit for LINQ to SQL.

How it Works

The True and False methods do nothing special: they are simply convenient shortcuts for creating an Expression> that initially evaluates to true or false. So the following:

var predicate = PredicateBuilder.True  ();

is just a shortcut for this:

Expression> predicate = c => true;

When you’re building a predicate by repeatedly stacking and/or conditions, it’s useful to have a starting point of either true or false (respectively). Our SearchProducts method still works if no keywords are supplied.

The interesting work takes place inside the And and Or methods. We start by invoking the second expression with the first expression’s parameters. An Invoke expression calls another lambda expression using the given expressions as arguments. We can create the conditional expression from the body of the first expression and the invoked version of the second. The final step is to wrap this in a new lambda expression.

More Examples

A useful pattern in writing a data access layer is to create a reusable predicate library. Your queries, then, consist largely of select and orderby clauses, the filtering logic farmed out to your library. Here's a simple example:

[object Object]public partial class Product
[object Object][object Object]

We can extend this by adding a method that uses PredicateBuilder:

public partial class Product
...{
  public static Expression> ContainsInDescription (
                                                params string[] keywords)
  ...{
    var predicate = PredicateBuilder.False();
    foreach (string keyword in keywords)
    ...{
      string temp = keyword;
      predicate = predicate.Or (p => p.Description.Contains (temp));
    }
    return predicate;
  }
}

This offers an excellent balance of simplicity and reusability, as well as separating business logic from expression plumbing logic. To retrieve all products whose description contains “BlackBerry” or “iPhone”, along with the Nokias and Ericssons that are selling, you would do this:

[object Object]var newKids  = Product.ContainsInDescription ("BlackBerry", "iPhone");
[object Object]
[object Object]var classics = Product.ContainsInDescription ("Nokia", "Ericsson")
[object Object]                      .And (Product.IsSelling());
[object Object]var query =
[object Object]  from p in Data.Products.Where (newKids.Or (classics))
[object Object]  select p;

The And and Or methods in boldface resolve to extension methods in PredicateBuilder.
An expression predicate can perform. the equivalent of an SQL subquery by referencing association properties. So, if Product had a child EntitySet called Purchases, we could refine our IsSelling method to return only those products that have sold a minimum number of units as follows:

[object Object]public static Expression> IsSelling (int minPurchases)
[object Object][object Object]