博客园_鹤冲天

c# 扩展方法奇思妙用高级篇九：OrderBy(string propertyName, bool desc)

2012-01-15T10:41:00Z

下面是 Queryable 类中最常用的两个排序的扩展方法：

1 2	public static IOrderedQueryable<TSource> OrderBy<TSource, TKey>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector); public static IOrderedQueryable<TSource> OrderByDescending<TSource, TKey>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector);

算上另外两个复杂点的，一共是四个方法，都是强类型的。

虽然强类型优点多多，但有些情况下确显得不够灵活。

强类型的缺点

比如 web 应用中有如下 Url：

~/orders?orderby=OrderDate&desc=true

在代码中我们如何写出强类型的查询？

1
2
3
4

IQueryable<Order> query = /**/;
string propertyName = /*从请求中获取，OrderDate*/;
bool desc = /*从请求中获取，true*/;
var data = query.Where(/*TODO: 如何写*/).ToArray();

单凭 Queryable 类中定义的 OrderBy 和 OrderByDescending，是不可能简单直接写出来的，除非硬编码。

那有如此做到灵活呢？我们从 Queryable 类定义的 OrderBy 和 OrderByDescending 方法下手，它们均有一个 Expression<Func<TSource, TKey>> 类型的 keySelector 参数。

先来试下能不能动态构建一个 keySelector。

动态构建 keySelector 参数

此部分要求对表达式树有一定了解，可查看：http://msdn.microsoft.com/zh-cn/library/bb397951(v=VS.100).aspx

代码则相当简单：

1
2
3
4
5
6

var type = typeof(Order);
var propertyName = "OrderDate";
//
var param = Expression.Parameter(type, type.Name);
var body = Expression.Property(param, propertyName);
var keySelector = Expression.Lambda(body, param);

最后三行代码动态构造了一颗表达式树：

和我们使用 lambda 表达式写出的效果是完全一样的：

这步比较顺利，下面来看如何调用：

调用 OrderBy

直接传入调用是不行的：

1	repository.OrderBy(keySelector);

因为前面构建的 keySelector 是 LambdaExpression 类型的，而 OrderBy 要求是 Expression<Func<Order, DateTime>> 。

但实质上 keySelector 就是 OrderBy 要求的类型：

因为强类型，居然不认自家人了！

可以通过强制类型转换来解决，编译运行都没问题：

1	repository.OrderBy((Expression<Func<Order, DateTime>>)keySelector);

但这样一来，又成了硬编码。

我们期望灵活，解决方法有很多种，这里只介绍最简单的一种，借助 .net 4 中 dynamic：

1	var orderedQueryable = Queryable.OrderBy(repository, (dynamic)keySelector);

因为扩展方法是不能被动态调用的（Extension methods cannot be dynamically dispatched），所以写成上面样子。

或将 keySelector 声明为 dynamic：

1 2	dynamic keySelector = Expression.Lambda(body, param); var orderedQueryable = Queryable.OrderBy(repository, keySelector);

OK，搞定！根据属性名排序太常用了，遂提取成了扩展方法：

OrderBy 扩展方法

将上面代码整理下，扩展方法就出来了：

1
2
3
4
5
6
7
8
9
10
11

public static class QueryableExtensions {
public static IQueryable<T> OrderBy<T>(this IQueryable<T> queryable, string propertyName) {
return OrderBy(queryable, propertyName, false);
}
public static IQueryable<T> OrderBy<T>(this IQueryable<T> queryable, string propertyName, bool desc) {
var param = Expression.Parameter(typeof(T));
var body = Expression.Property(param, propertyName);
dynamic keySelector = Expression.Lambda(body, param);
return desc ? Queryable.OrderByDescending(queryable, keySelector) : Queryable.OrderBy(queryable, keySelector);
}
}

注意，上面代码执行没问题，但效率不好。因为每次都要动态生成表达式树，另外动态调用也会造成一定性能损失。

想提高效率的话，可把动态生成的表达式树缓存起来，参考如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

public static class QueryableExtensions {
public static IQueryable<T> OrderBy<T>(this IQueryable<T> queryable, string propertyName) {
return QueryableHelper<T>.OrderBy(queryable, propertyName, false);
}
public static IQueryable<T> OrderBy<T>(this IQueryable<T> queryable, string propertyName, bool desc) {
return QueryableHelper<T>.OrderBy(queryable, propertyName, desc);
}
static class QueryableHelper<T> {
private static Dictionary<string, LambdaExpression> cache = new Dictionary<string, LambdaExpression>();
public static IQueryable<T> OrderBy(IQueryable<T> queryable, string propertyName, bool desc) {
dynamic keySelector = GetLambdaExpression(propertyName);
return desc ? Queryable.OrderByDescending(queryable, keySelector) : Queryable.OrderBy(queryable, keySelector);
}
private static LambdaExpression GetLambdaExpression(string propertyName) {
if (cache.ContainsKey(propertyName)) return cache[propertyName];
var param = Expression.Parameter(typeof(T));
var body = Expression.Property(param, propertyName);
var keySelector = Expression.Lambda(body, param);
cache[propertyName] = keySelector;
return keySelector;
}
}
}

这里并发不是多大问题，如若考虑，可使用 ConcurrentDictionary<TKey, TValue> 类。

使用

很方便的：

1 2	var data1 = productRepository.OrderBy("Name"); var data2 = orderRepository.OrderBy("OrderDate", true);

《c#扩展方法奇思妙用》系列文章已有 25 篇，欢迎阅读。

PS：简单编码，快乐生活！

本文链接

Linq：切勿使用 Count() > 0 来判断集合非空

2011-12-11T12:51:00Z

Linq 出现之前，我们通常使用下面的方式来判断集合是否非空，即集合包含元素：

1
2
3
4
5
6
7
8

var array = new int[0];
var b1 = array.Length > 0;

var list = new List<string>();
var b2 = list.Count > 0;

var collection = new Collection<double>();
var b3 = collection.Count > 0;

使用 Length 或 Count 属性，上面的写法没有问题。

但到了 Linq 时代，Enumerable.Count 扩展方法“统一了“ Length 和 Count 属性，于是就有了下面判断非空的写法：

1
2
3
4
5

public static void SomeAction<T>(IEnumerable<T> source){
if (source.Count() > 0){
//...
}//...
}

这种写法可以，运行也正常，但可能会产生非常严重的性能的问题。

注意是可能，并不是一定，上面的方法如果传入的是 Array、List<T>或Collection<T>，不会有问题。

那么什么时候会出问题呢？我们来看如下方法：

1
2
3
4
5
6

public static IEnumerable<int> GetNums(int start, int count)
{
var end = start + count;
for (int i = start; i < end; i++)
yield return i;
}

如下调用时：

1 2	var nums = GetNums(0, int.MaxValue); SomeAction(nums);

执行速度会相当慢，我的电脑大约用了 70 秒的时间来执行 source.Count() > 0。

分析下的话，你会发现 GetNums 第 5 行代码 yield return i 执行了 int.MaxValue 次，有必要吗？

其实只要返回一个元素我们就可以断定集合非空，完全不需要将所有的元素返回。

那又如何来判断呢？我们可以使用 Enumerable.Any 扩展方法：

将 SomeAction 方法修改如下：

1
2
3
4
5

public static void SomeAction<T>(IEnumerable<T> source){
if(source.Any()){ // 切勿使用 source.Count() > 0
//...
}//...
}

再次调用，你会发现执行时间可以忽略不计了。

总结下规律， Count() > 0 遇上 yeild return 必定会出现性能问题。

Enumerable.Any 扩展方法可以解决我们的问题，但这个方法在命名上似乎有些问题，总感觉有点不顺，如若判断集合为空：

1 2	if (!source.Any()) { //... }

! source.Any() 更显得绕口，我们可以新增两个扩展方法 IsEmpty、IsNotEmpty 来解决，请参考我的文章：

《 c# 扩展方法奇思妙用基础篇十：IsEmpty、IsNotEmpty 扩展》

本文链接

c# 扩展方法奇思妙用基础篇十：IsEmpty、IsNotEmpty 扩展

2011-12-10T14:45:00Z

这两个扩展方法很简单：

1
2
3
4
5
6
7
8

public static class EnumerableExtensions {
public static bool IsEmpty<T>(this IEnumerable<T> source) {
return !source.Any();
}
public static bool IsNotEmpty<T>(this IEnumerable<T> source) {
return source.Any();
}
}

Enumerable.Any 方法用来判断序列（或集合）是否包含元素，但这个名字不如 IsNotEmpty 更贴切，!source.Any() 更是绕口，于是便有了 IsEmpty 和 IsNotEmpty 两个扩展方法。

有一点要注意，不少朋友使用 source.Count() > 0 来判断是否包含元素，是不恰当的，可能会造成效率严重低下，具体原因另撰文详述。

《c#扩展方法奇思妙用》系统文章从 2009 年 08 月开始写起，到现在一共有了 25 篇，欢迎阅读：

基础篇：	中文处理、string 常用扩展、byte 常用扩展、Random 扩展、Dictionary<TKey, TValue> 扩展、WhereIf 扩展、IsBetween 通用扩展、WhereIf 扩展、Distinct 扩展、 IsEmpty、IsNotEmpty 扩展
高级篇：	改进 Scottgu 的 "In" 扩展、Aggregate扩展其改进、Enumerable.Cast<T>应用、对扩展进行分组管理、ToString(string format) 扩展、WinForm 控件选择器、树”通用遍历器、Type类扩展
变态篇：	由Fibonacci数列引出“委托扩展”及“递推递归委托”、封装 if/else、swith/case及while、switch/case 组扩展、string 的翻身革命
性能篇：	扩展方法性能初测
MVC篇：	巧用扩展方法优先级，美化所有页面TextBoxFor文本框

本文链接

四行代码创建复杂（无限级）树

2011-12-09T12:38:00Z

最近两三天一直在做树方面的基础工作，碰巧今天在博客园看到一篇文章《C#中一种通用的树的生成方式》，粗略浏览下，感觉有不够强大。

对比而言，感觉自己的方式更好些，只需要四行代码就可以创建一颗复杂的无限级树。

在此分享一下，请大家先看两个运行截图：

下面，我们来看如何实现，先给出树节点的两个类：

树节点类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

public class TreeNode {
private List<TreeNode> _children;

public TreeNode(string text, object value = null) {
this.Text = text;
this.Value = value;
_children = new List<TreeNode>();
}

public string Text { get; private set; }
public object Value { get; protected set; }
public TreeNode Parent { get; set; }
public IEnumerable<TreeNode> Children { get { return _children; } }

public void Add(TreeNode childNode) {
_children.Add(childNode);
childNode.Parent = this;
}
public void Remove(TreeNode childNode) {
_children.Remove(childNode);
}
public override string ToString() {
return Text;
}
}

一个比较标准的树节点，有父结点和多个子节点。Value 属性用来保存和树结点相关的对象的值。

再加上一个泛型版本的：

1
2
3
4
5
6

public class TreeNode<T> : TreeNode {
public TreeNode(string text, T t)
: base(text, t) {
}
public new T Value { get { return (T)base.Value; } }
}

算是一个强类型的树节点吧。

为了方便树节点的操作，我给 TreeNode 编写了一些扩展方法，如下给出本文要用的一个：

查找所有叶子节点的扩展方法

1
2
3
4
5
6
7
8
9
10
11
12

public static class TreeNodeExtensions {
public static IEnumerable<TreeNode> GetLeafNodes(this TreeNode treeNode) {
foreach (var child in treeNode.Children) {
if (child.Children.Any()) {
foreach (var descendant in GetLeafNodes(child))
yield return descendant;
}
else
yield return child;
}
}
}

一个迭推调用。

最后到了重点：

TreeBuilder 相关类

TreeBuilder 类：

1
2
3
4
5
6
7
8
9
10
11

public static class TreeBuilder {
public static BuildRootContext Build(string text) {
var root = new TreeNode(text);
return new BuildRootContext(root);
}
internal static TreeNode<T> BuildNode<T>(T t, Func<T, string> textSelect = null) {
var text = textSelect != null ? textSelect(t) : Convert.ToString(t);
var node = new TreeNode<T>(text, t);
return node;
}
}

BuildRootContext 类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

public class BuildRootContext {
private TreeNode _tree;

public BuildRootContext(TreeNode tree) {
this._tree = tree;
}

public BuildChildrenContext<T> SetItems<T>(IEnumerable<T> items) {
foreach (var item in items) {
var node = TreeBuilder.BuildNode(item);
_tree.Add(node);
}
return new BuildChildrenContext<T>(_tree);
}
public TreeNode Tree { get { return _tree; } }
}

BuildChildrenContext 类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

public class BuildChildrenContext<T> {
private TreeNode _tree;

public BuildChildrenContext(TreeNode tree) {
this._tree = tree;
}

public TreeNode Tree { get { return _tree; } }

public BuildChildrenContext<V> SetItems<V>(Func<T, IEnumerable<V>> itemSelector, Func<V, string> textSelect = null) {
var leafNodes = _tree.GetLeafNodes().OfType<TreeNode<T>>();
foreach (var leafNode in leafNodes) {
foreach (var child in itemSelector(leafNode.Value)) {
var node = TreeBuilder.BuildNode(child, textSelect);
leafNode.Add(node);
}
}
return new BuildChildrenContext<V>(_tree);
}
public BuildChildrenContext<T> SetRecursiveItems(Func<T, IEnumerable<T>> itemSelector,
Func<T, string> textSelect = null) {
var context = this;
while (_tree.GetLeafNodes().OfType<TreeNode<T>>().Any(n => itemSelector(n.Value).Any()))
context = context.SetItems<T>(itemSelector, textSelect);
return context;
}
}

通过这三个类即可达到文首图片中的效果，但实现可不是最佳方式，效率没太考虑，命名也不太好。

不过可以运行，先用上，慢慢改进吧！

简单使用说明

有限级树

像第一张图片中的产品树，只有两级：类别和产品，使用如下代码创建：

1
2
3
4

var tree = TreeBuilder.Build("产品")
.SetItems(categories)
.SetItems(category => products.Where(p => p.Category == category))
.Tree;

第 1 行，构建根结点，传入一个字符串作为根结点的文本。

第 2 行，指定树的第一级，必须传入一个集合，上面传入的是 IEnumerable<Category>。

第 3 行，指定树的第二级，传入的是 Func<Category, IEnumerable<Product>>。

第 4 行，调用 Tree 属性，返回根结点，也是树了。

如果需要更多的级数，可将代码写在调用 Tree属性之前，也就是第 3 行和第 4 行之间。

增加一级，可以写成下面的样子（可没什么实际意义）：

1
2
3
4
5

var tree = TreeBuilder.Build("产品")
.SetItems(categories)
.SetItems(category => products.Where(p => p.Category == category))
.SetItems(product=>product.Name)
.Tree;

无限级树

第二张图片中的员工树是无限级的，因为员工的下属还可能有下属，是没有限制级数的。使用 SetRecursiveItems 方法构建：

1
2
3
4

var tree = TreeBuilder.Build("员工树")
.SetItems(employees.Where(e => e.ReportsTo == null))
.SetRecursiveItems(e => e.Subordinates)
.Tree;

其代码它部分和有限级树相同。

还可以在员工树增加层次，之上增加部门，之后增加爱好等等，调用 SetItmes 即可。

部门无限然后员工无限，也是可以的。

总结

通过 TreeBuilder 可以让我们极其方便的创建很复杂的树，让我们把更多的精力放在业务逻辑上（而不是程序或界面逻辑）。

文中代码编写仓促，如有 Bug 请在回复中告知。

如果本文对你有帮助或启发，不妨推荐一下让更多的朋友看到。

在线演示：

你可以通过下面两个网址，看到通过本文的代码生成的树：

源码下载：TreeDemo.rar （15KB）

本文链接

ASP.NET MVC：自定义 Route 让你的 Url 更优雅

2011-12-05T12:11:00Z

如今，互联网越来越注重简单优雅的 Url，对比下面两个：

我相信大多数朋友会更喜欢第二种方式：小写，使用负（减）号作为连字符。

本文使用自定义 Route 来达到方式二的效果，只需增加几个类和简单修改下 global.asax 文件。

Route 是双向的

Route 的基本概念我就不多说了，这里重点强调一下 ASP.NET MVC 中 Route 是双向的，这可以从 RouteBase 类的定义可以看出：

1
2
3
4

public abstract class RouteBase{
public abstract RouteData GetRouteData(HttpContextBase httpContext);
public abstract VirtualPathData GetVirtualPath(RequestContext requestContext, RouteValueDictionary values);
}

GetRouteData 用于解析 Url，GetVirtualPath 用于生成 Url。

在开始编写我们的 Route 类之前，我们需要一个用于处理字符串的静态类：

StringElegantHelper 类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

internal static class StringElegantHelper {

public static readonly char minus = '-';

public static string Elegant(string s) {
var builder = new StringBuilder();
var index = 0;
foreach (var c in s) {
if (c >= 'A' && c <= 'Z') {
if (index > 0) builder.Append(minus);
builder.Append(char.ToLower(c));
}
else if (c == minus) {
builder.Append(minus);
builder.Append(minus);
}
else
builder.Append(c);
index++;
}
return builder.ToString();
}

public static string DeElegant(string s) {
var builder = new StringBuilder();
var iterator = s.GetEnumerator();
while (iterator.MoveNext()) {
if (iterator.Current != minus) {
builder.Append(iterator.Current);
continue;
}
if (!iterator.MoveNext()) {
builder.Append(minus);
break;
}
if (iterator.Current == minus)
builder.Append(minus);
else
builder.Append(iterator.Current);
}
return builder.ToString();
}
}

StringElegantHelper 中有两个方法 Elegant 和 DeElegant，将分别用在 GetVirtualPath 和 GetRouteData 方法中，用于生成和解析优雅的 Url。

这两方法也可以使用正则表达式来实现，但我认为效率不高，就采用了上面这种最朴实的方式。

有了 StringElegantHelper 类，写出 ElegantRoute 就简单多了：

ElegantRoute 类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

public class ElegantRoute : Route {

public static readonly string[] ToElegant = new [] { "controller", "action" };

public ElegantRoute(string url, RouteValueDictionary defaults, RouteValueDictionary constraints, RouteValueDictionary dataTokens, IRouteHandler routeHandler)
: base(url, defaults, constraints, dataTokens, routeHandler) { }

public override RouteData GetRouteData(HttpContextBase httpContext) {
var result = base.GetRouteData(httpContext);
if (result == null) return null;

foreach (var key in ToElegant)
HandleItem(result.Values, key, StringElegantHelper.DeElegant);
return result;
}

public override VirtualPathData GetVirtualPath(RequestContext requestContext, RouteValueDictionary values) {
var elegantValues = new RouteValueDictionary(values);
foreach (var key in ToElegant)
HandleItem(elegantValues, key, StringElegantHelper.Elegant);
return base.GetVirtualPath(requestContext, elegantValues);
}

private void HandleItem(RouteValueDictionary dict, string key, Func<string, string> handler) {
if (!dict.ContainsKey(key)) return;
//
var value = dict[key];
if (!(value is string)) return;
//
dict[key] = handler(value as string);
}
}

注意，上面代码中只对 controller 和 action 的路由值进行了“优雅”处理，其它值并没有，为什么呢？

大家可以考虑以下网址：

~/customers/details/ANTON

全部处理的话会变成：

~/customers/details/a-n-t-o-n

代码其他部分比较简单，不多说了。

最后，还需要几个扩展方法，以方便在 global.asax 文件中使用：

ElegantRouteExtensions 类

1
2
3
4
5
6
7
8
9
10
11

public static class ElegantRouteExtensions {
public static ElegantRoute MapElegantRoute(this RouteCollection routes, string name, string url, object defaults) {
var route = new ElegantRoute(url,
new RouteValueDictionary(defaults),
new RouteValueDictionary(), //constraints
new RouteValueDictionary(), //dataTokens
new MvcRouteHandler());
routes.Add(name, route);
return route;
}
}

我只写出一个，大家可根据需要添加。

使用 ElegantRouter

借助上面的扩展方法，使用就很相当简单了。

global.asax 文件中，把 routes.MapRoute 替换为 routes.MapElegantRoute 即可：

1
2
3
4
5

routes.MapElegantRoute( // MapRoute
"Default",
"{controller}/{action}/{id}",
new { controller = "Home", action = "Index", id = UrlParameter.Optional }
);

运行起来验证，点下右上角的 [ Log On ] 链接：

ElegantRoute 生成和解析通过。

本文代码未严格测试，如有 bug，请在回复中告知，不胜感激！

源码下载：ElegantRouteDemo.rar （75KB）

在线演示：http://demo.highsoft.cc/products

本文链接

你能指出这个 ForEach 扩展方法中的错误吗？

2011-10-07T08:06:00Z

带返回值的 ForEach 扩展

Linq 中没有原生的 ForEach 扩展方法，我们可以很轻松的扩展一个：

1
2
3

public static void ForEach<T>(this IEnumerable<T> source, Action<T> action) {
foreach (var element in source) action(element);
}

上面这个 ForEach 是没有返回值的，写完 ForEach 本句代码也就结束了，这与 Linq 链式编程风格是不符的。

细心查看的话，你会发现 Enumerble 和 Queryable 中的每个扩展方法都是有返回值的，这样才能保证代码链链不断。

改进下，让 ForEach 返回 IEnumerable<T>，相信不少朋友会错误地写出如下的代码：

1
2
3
4

public static IEnumerable<T> ForEach<T>(this IEnumerable<T> source, Action<T> action) {
foreach (var element in source) action(element);
return source;
}

园子里中就有这么一篇文章是这样实现的，文章还被选入了博客文库。你能胜过小编，指出其中的错误吗。

通过单元测试查找错误

我们来测试下这个扩展方法，先写第一个测试：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

public class Employee {
public string Name { get; set; }
public decimal Bonus { get; set; }
}
[TestMethod()]
public void ForEachTest() {
var employees = new Employee[] {
new Employee{ Name = "张三", Bonus = 500 },
new Employee { Name = "李四", Bonus = 800}
};
var actualBonus = employees
.ForEach(e => e.Bonus += 200)
.First(e => e.Name == "李四")
.Bonus;
Assert.AreEqual(1000, actualBonus);
}

说明：在 .NET Framework 2.0 版中，Array 类实现 System.Collections.Generic.IList<T>、System.Collections.Generic.ICollection<T> 和 System.Collections.Generic.IEnumerable<T> 泛型接口。由于实现是在运行时提供给数组的，因而对于文档生成工具不可见。因此，泛型接口不会出现在 Array 类的声明语法中，也不会有关于只能通过将数组强制转换为泛型接口类型（显式接口实现）才可访问的接口成员的参考主题。将某一数组强制转换为这三种接口之一时需要注意的关键一点是，添加、插入或移除元素的成员会引发 NotSupportedException。

摘自：http://msdn.microsoft.com/zh-cn/library/system.array.aspx

这个测试是可以顺利通过的，但不能说明代码是正确的，我们再来写一个测试。

Enumerable.Range 方法可以生成整数序列，我们就调用它来作为 source 参数：

1
2
3
4
5
6

[TestMethod()]
public void ForEachTest2() {
var nums = Enumerable.Range(1, 10);
var actual = nums.ForEach(i => i *= 10).First();
Assert.AreEqual(10, actual);
}

第 4 行仅为了测试，其它情况下使用 Select(i => i*10) 更为恰当。

这次测试通不过了：

应该思考下了，自已动脑解决胜过他人直接告知。

再给出最后一个测试，看了基本就能找出错误所在了：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

public IEnumerable<Employee> GetEmployees() {
yield return new Employee {Name = "张三", Bonus = 500};
yield return new Employee {Name = "李四", Bonus = 800};
}

[TestMethod()]
public void ForEachTest3() {
var employees = GetEmployees();
var actualBonus = employees
.ForEach(e => e.Bonus += 200)
.First(e => e.Name == "李四")
.Bonus;
Assert.AreEqual(1000, actualBonus);
}

问题所在

通过上面几个测试，应该发现 yield 的特性会让上面的 ForEach 出问题，请参看 Artech 的文章《从yield关键字看IEnumerable和Collection的区别》进行更深入的了解。

如果你使用的是 IQueryable<T> 问题可能出现，要考虑一些 ORM 框架的缓存情况。

正确实现

那么怎么正确实现 ForEach 扩展方法呢，我想还是留给大家来思考完成吧，一味接受可不是好的学习方式。

另外，还可以实现如下签名的扩展，以方便使用：

1	public static IEnumerable<T> ForEach<T>(this IEnumerable<T> source, Action<T, int> action) {/.../ }

有关 Linq 中为什么没有原生的的 ForEach 扩展的讨论，请参见文章：

本文链接

复用 Entity Framework 中英语单复数形式变换的类

2011-09-21T13:24:00Z

数据库表名用复数、实体类名用单数，集合属性用复数…编程中经常会遇到英语单复数变换的问题，你能准确处理吗？对我来说，十年前或许可以，but don't worry，我们有现成的类提供些类服务，来自 EntityFrameWork。

使用 ILSpy 打开 EntityFramework.dll（v4.1），处理单复数的相关类位于 System.Data.Entity.ModelConfiguration.Design.PluralizationServices 命名空间下：

其中 PluralizationService 是单复数变换服务的抽象基类，定义如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

internal abstract class PluralizationService {
public CultureInfo Culture {
get;
protected set;
}
public abstract bool IsPlural(string word);
public abstract bool IsSingular(string word);
public abstract string Pluralize(string word);
public abstract string Singularize(string word);
/// <summary>
/// Factory method for PluralizationService. Only support english pluralization.
/// Please set the PluralizationService on the System.Data.Entity.Design.EntityModelSchemaGenerator
/// to extend the service to other locales.
/// </summary>
/// <param name="culture">CultureInfo</param>
/// <returns>PluralizationService</returns>
public static PluralizationService CreateService(CultureInfo culture) {
if (culture.TwoLetterISOLanguageName == "en") {
return new EnglishPluralizationService();
}
throw new NotImplementedException("We don't support locales other than english yet");
}
}

EnglishPluralizationService 是英文的具体实现类，包含了规则变换和不规则变换，代码太长就不贴出了。

估计很多朋友会和我一样会，担心这个实现是否完整。我简单查看了下源码，发现了这个单词：

1	pneumonoultramicroscopicsilicovolcanoconiosis

不用数了，一共是 45 个字母，这可是最长的英语单词。这么长（估计实际用的也不多）的单词都收录了，再加上 EnglishPluralizationService 类 2451 行的代码，想必非常完整了。

但不幸的是，这些类都是 internal，没法直接用。不过我们可以使用 ILSpy 把这几个类提出来，供我们享用。

ILSpy 可以将整个 dll 反编译成项目，也可以将单个类反编译成文件：

但不能直接反编译一个命名空间，有点遗憾。

余下的工作的和怎么用，就不用我多说了吧。

分享一份我处理好的源码：PluralizationServices.rar （8KB，VS2010）

本文链接

ASP.NET MVC：Expression Trees 作为参数简化查询二

2011-09-18T09:25:00Z

前文《ASP.NET MVC：Expression Trees 作为参数简化查询》中提出可以将 Expression Trees 用作查询 Action 的参数来简化编码：

1
2
3
4

public ActionResult Index([QueryConditionBinder]Expression<Func<Employee, bool>> predicate) {
var employees = repository.Query().Where(predicate);
return View("Index", employees);
}

文中给出的 QueryConditionExpressionModelBinder 类，比较僵化，无法满足实际要求。本文将会从这个类为起点，构建一个灵活的解决方案。

本文的内容稍有枯燥，先给出最终的运行截图，给大家提提神：

演示网站运行截图

在线演示：http://demos.ldp.me/employees

下图显示的 Expression 是根据查询条件动态生成的：

调试截图：

设计目标

支持以下类型查询：

相等查询
字符串查询：完全匹配、模糊查询、作为开始、作为结束；
日期查询（不考虑时间）、日期范围查询；
比较查询：大于、大于等于、小于、小于等于；
…
正确处理可空类型

阻止某些查询：

ID查询
某些保密属性，如内部价格属性等

扩展性：

系统容易扩展，开放支持加入新的查询类型

易用性：

简单使用

其它：

查询数据验证，配合 MVC 相应机制，对错误输入给出提示。

思考

想法源自 Entity Framework：

EF 中的 Convention

在 EF Code First 中，Entity 与数据库 Table 之间映射采用 Convention (约定) 的方式：

PluralizingTableNameConvention：实体使用单数形式，自动对应数据库中复数形式的表名；
IdKeyDiscoveryConvention：自动找寻主键，名为 Id 或 Entity 类名 + Id 的属性自动认为是主键；

System.Data.Entity.ModelConfiguration.Conventions 命名空间中有很多这样的 Convention。这些 Convention 都是被大多人公认的，EF 运行时会加载这些 Convention，因此我们使用 EF 会相当简单，不需要像 NH 那样进行大量繁琐无聊的映射配置工作。

如果你认可其中的某条 Convention 你可以将它移除：

1
2
3
4
5

public class NorthwindDbContext : DbContext
{
protected override void OnModelCreating(DbModelBuilder modelBuilder) {
modelBuilder.Conventions.Remove<IdKeyDiscoveryConvention>();
}

不错吧，但 EF 不允许添加新的 Convention，有点遗憾。

分解出 Convention

借鉴 EF 的思路，我们可以分解出以下 Convention：

ValueTypeEqualsConvention：值类型相等，年龄 == 18、婚否 = false；
StringContainsConvention：字符串包含，即模糊查询；
DateEqualsConvention：日期等于，忽略时间；
ValueTypeCompareConvention：值类型比较，价格大于 12.00；
BetweenDatesConvention：时间界于两个日期之间；
IDForbiddenConvention：禁止对 ID 查询。

还有一点，要将各个条件组合起来，如：(年龄 <= 18) 并且 (婚否 = false)，或者 (年龄 <= 18) 或者 (婚否 = false)。因此，还要定义用于连接组合的 Convention：

AndCombineConvention：并且，在页面查询中，这个比较常用，我们设成默认的；
OrCombinedConvention：或者；
XXXComplexCombineConvention：更加复杂的情况，如：(存款 > 100,000,000) Or ((年龄 <= 18) 并且 (婚否 = false))。

可设置的 Order 属性

给每个 Convention 设置一个优先顺序号，大的优先级高：

StringContainsConvention、DateEqualsConvention 优先于 ValueTypeEqualsConvention；
BetweenDatesConvention 优先于 DateEqualsConvention。

即采用了 StringContainsConvention 就不会再采用 ValueTypeEqualsConvention。

编码时会根据实际应用给每个 Convention 设置一个默认的合理的 Order 值，但为了灵活通用，允许修改，Order 是一个 get-set 属性。

可以添加新的 Convention 以满足更多应用

EF 只能移除不能添加，有时感不方便，不太符合 OCP（Open-Closed principle）。

编码实现

抽象出接口

根据上面的分析，可以提取出下面三个接口：

IConvention 接口，代表所有的约定：

1
2
3 public interface IConvention {
int Order { get; set; }
}

IPropertyExpressionConvention 接口，将单个查询条件转换为 Expression：

1
2
3

public interface IPropertyExpressionConvention: IConvention {
Expression BuildExpression(BuildPropertyExpressionContext context);
}

IExpressionCombineConvention 接口，将多个查询 Expression 进行合并：

1
2
3

public interface IExpressionCombineConvention : IConvention {
Expression Combine(IDictionary<string, Expression> expressions);
}

修改 QueryConditionExpressionModelBinder 类

修改后代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

public class QueryConditionExpressionModelBinder : IModelBinder {
private ConventionConfiguration _conventionConfiguration;

public QueryConditionExpressionModelBinder(ConventionConfiguration conventionConfiguration) {
_conventionConfiguration = conventionConfiguration;
}

public QueryConditionExpressionModelBinder(): this(ConventionConfiguration.Default) { }

public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext) {
var modelType = GetModelTypeFromExpressionType(bindingContext.ModelType);
if (modelType == null) return null;

var parameter = Expression.Parameter(modelType, modelType.Name[0].ToString().ToLower());

var dict = new Dictionary<string, Expression>();
var propertyExpressionConvertions = _conventionConfiguration.GetConventions<IPropertyExpressionConvention>();
foreach (var property in modelType.GetProperties()){
foreach (var convention in propertyExpressionConvertions) {
var context = new BuildPropertyExpressionContext(
property,
bindingContext.ValueProvider,
controllerContext.Controller.ViewData.ModelState,
parameter.Property(property.Name)
);
var expression = convention.BuildExpression(context);
if(expression != null){
dict.Add(property.Name, expression);
break;
}
if (context.IsHandled) break;
}
}
var body = default(Expression);
foreach (var convention in _conventionConfiguration.GetConventions<IExpressionCombineConvention>())
{
body = convention.Combine(dict);
if (body != null) break;
}
//if (body == null) body = Expression.Constant(true);
return body.ToLambda(parameter);
}
/// <summary>
/// 获取 Expression<Func<TXXX, bool>> 中 TXXX 的类型
/// </summary>
private Type GetModelTypeFromExpressionType(Type lambdaExpressionType) {

if (lambdaExpressionType.GetGenericTypeDefinition() != typeof (Expression<>)) return null;

var funcType = lambdaExpressionType.GetGenericArguments()[0];
if (funcType.GetGenericTypeDefinition() != typeof (Func<,>)) return null;

var funcTypeArgs = funcType.GetGenericArguments();
if (funcTypeArgs[1] != typeof (bool)) return null;
return funcTypeArgs[0];
}
/// <summary>
/// 获取属性的查询值并处理 Controller.ModelState
/// </summary>
private object GetValueAndHandleModelState(PropertyInfo property, IValueProvider valueProvider, ControllerBase controller) {
var result = valueProvider.GetValue(property.Name);
if (result == null) return null;

var modelState = new ModelState {Value = result};
controller.ViewData.ModelState.Add(property.Name, modelState);

object value = null;
try{
value = result.ConvertTo(property.PropertyType);
}
catch (Exception ex){
modelState.Errors.Add(ex);
}
return value;
}
}

高亮代码为修改或新增部分。

QueryConditionExpressionModelBinder 中使用了 ConventionConfiguration 类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

public class ConventionConfiguration {

public static ConventionConfiguration Default = new ConventionConfiguration();

static ConventionConfiguration() {
Default.Conventions.Add(new ValueTypeEqualsConvention());
Default.Conventions.Add(new StringContainsConvention());
Default.Conventions.Add(new DateEqualsConvention());
Default.Conventions.Add(new BetweenDatesConvention());
//
Default.Conventions.Add(new AwalysTrueCombineConvention());
Default.Conventions.Add(new OrCombineConvention());
}

public ConventionConfiguration() {
Conventions = new HashSet<IConvention>();
}
public HashSet<IConvention> Conventions { get; private set; }

internal IEnumerable<T> GetConventions<T>() where T: IConvention {
return Conventions
.OfType<T>()
.OrderByDescending(c => c.Order);
}
}

实现具体 Converntion：

ValueTypeEqualsConvention

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

public class ValueTypeEqualsConvention : PropertyExpressionConventionBase {

public ValueTypeEqualsConvention():base(1) {}

public override Expression BuildExpression(BuildPropertyExpressionContext context) {
if (!context.Property.PropertyType.IsValueType) return null;

var queryValue = context.ValueProvider.GetQueryValue(context.Property.Name, context.Property.PropertyType);
context.ModelState.AddIfValueNotNull(context.Property.Name, queryValue.ModelState);
context.IsHandled = queryValue.ModelState != null;

if(queryValue.Value == null) return null;
return context.PropertyExpression.Equal(Expression.Constant(queryValue.Value));
}
}

StringContainsConvention

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

public class StringContainsConvention : PropertyExpressionConventionBase {

public StringContainsConvention():base(10) { }

public override Expression BuildExpression(BuildPropertyExpressionContext context) {
if (context.Property.PropertyType != typeof(string)) return null;

var queryValue = context.ValueProvider.GetQueryValue(context.Property.Name, context.Property.PropertyType);
context.ModelState.AddIfValueNotNull(context.Property.Name, queryValue.ModelState);
context.IsHandled = queryValue.ModelState != null;

if ((queryValue.Value as string).IsNullOrEmpty()) return null;
return context.PropertyExpression.Call("Contains", Expression.Constant(queryValue.Value));
}
}

DateEqualsConvention

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

public class DateEqualsConvention: PropertyExpressionConventionBase {
public DateEqualsConvention():base(10) { }

public override System.Linq.Expressions.Expression BuildExpression(BuildPropertyExpressionContext context) {
if (context.Property.PropertyType.NotIn(typeof(DateTime), typeof(DateTime?))) return null;
if (!context.Property.Name.EndsWith("day", true, CultureInfo.CurrentCulture) &&
!context.Property.Name.EndsWith("date", true, CultureInfo.CurrentCulture)) return null;

var queryValue = context.ValueProvider.GetQueryValue(context.Property.Name, typeof(DateTime));
context.ModelState.AddIfValueNotNull(context.Property.Name, queryValue.ModelState);
context.IsHandled = queryValue.ModelState != null;
if (queryValue.Value == null) return null;

var date = ((DateTime)queryValue.Value).Date;
var expression = context.PropertyExpression;
if (expression.Type == typeof(DateTime?)) expression = expression.Property("Value");
return expression.Property("Date").Equal(Expression.Constant(date));
}
}

AndCombineConvention

1
2
3
4
5
6
7
8

public class AndCombineConvention : IExpressionCombineConvention {
public int Order { get; set; }
public System.Linq.Expressions.Expression Combine(IDictionary<string, System.Linq.Expressions.Expression> expressions) {
if(expressions.Count > 0)
return expressions.Values.Aggregate((a, e) => a.OrElse(e));
return null;
}
}

特别注意下 DateEqualsConvention，只对名称以 day 或 date 结尾（不区分大小）的 DateTime 或 DateTime？属性进行处理，如 Employee.Birthday、Employee.HireDate。

项目类图

目前实现中主要有以下类和接口：

扩展方法类未列出。

QueryConditionExpressionModelBinder 使用

直接使用

1
2
3
4

public ActionResult Index([QueryConditionBinder]Expression<Func<Employee, bool>> predicate) {
var employees = repository.Query().Where(predicate);
return View("Index", employees);
}

或配置后使用

若你有新创建的 Convention，可以在 Global.asax 文件中 MvcApplication.Application_Start 方法中进行加入配置：

1	ConventionConfiguration.Default.Conventions.Add(new YourConvention());

如果默认的 Conversions 不满足你的要示，可以移除后重新增加：

1
2
3
4

ConventionConfiguration.Default.Conventions.Clear();
ConventionConfiguration.Default.Conventions.Add(new ValueTypeEqualsConvention());
ConventionConfiguration.Default.Conventions.Add(new DateEqualsConvention { Order = 1000 });
ConventionConfiguration.Default.Conventions.Add(new YourConvention{ Order = 2000});

因为 Order 属性是可修改的，添加时可以重新指定优先级。

或都你可以给某一个查询单独配置 Convention：

1
2
3

var cfg = new ConventionConfiguration();
cfg.Conventions.Add(new StringContainsConvention());
ModelBinders.Binders.Add(typeof(Expression<Func<Order, bool>>), new QueryConditionExpressionModelBinder(cfg));

这时，就不要再使用 QueryConditionBinderAttribute 了：

1
2
3
4
5
6
7

public class OrdersController : Controller{
private OrdersRepository repository = new OrdersRepository();
public ViewResult Index(Expression<Func<Order, bool>> predicate) {
var orders = repository.Query().Where(predicate);
return View(orders);
}
}

后记

根据你的项目，创建适合的 Convention，相信 QueryConditionExpressionModelBinder 一定会帮你省下很多时间。

本文中代码编写仓促，尚未进行严格测试，使用时请注意。如有 bug 请回复给我，谢谢！

后续还有相关文章，实现禁止对某些属性查询的 Convention，以及复杂条件组合 Convention 等等。

源码下载：MvcQuery2.rar （1733KB，VS2010 MVC3）

在线演示：http://demos.ldp.me/employees

本文链接

ASP.NET MVC：Expression Trees 作为参数简化查询

2011-09-16T15:09:00Z

引言

ASP.NET MVC 引入了 ModelBinder 技术，让我们可以在 Action 中以强类型参数的形式接收 Request 中的数据，极大的方便了我们的编程，提高了生产力。在查询 Action 中，我们可以将 Expression Trees 用作参数，通过自定义的 ModelBinder 动态自动构建查询表达式树，进一步发挥 MVC 的威力，简化编码工作。

先给出本文中使用的 Model：

1
2
3
4
5
6
7
8

public class Employee {
public int ID { get; set; }
public string FirstName { get; set; }
public string LastName { get; set; }
public bool Sex { get; set; }
public DateTime? Birthday { get; set; }
public string Remark { get; set; }
}

MVC 查询和存在的不足

下面是一个查询 Employee 的 Action，在 MVC 项目中经常可以见到：

1
2
3
4
5
6
7
8
9
10
11
12

public ActionResult Index(string firstName, string lastName, DateTime? birthday, bool? sex) {
var employees = repository.Query();
if (firstName.IsNotNullAndEmpty())
employees = employees.Where(e => e.FirstName.Contains(firstName));
if (firstName.IsNotNullAndEmpty())
employees = employees.Where(e => e.LastName.Contains(lastName));
if (birthday.HasValue)
employees = employees.Where(e => e.Birthday.Value.Date == birthday.Value.Date);
if (sex.HasValue)
employees = employees.Where(e => e.Sex == sex);
return View(employees);
}

得益于 MVC 的绑定技术，我们可以简单通过 Action 的参数来获取请求的值，很少再使用 Request["XXXX"] 的方式。

仔细观察，会发现上面这个 Action 中充斥着大量 if 判断，以致代码行数比较多，不是特别清晰。可以借助本人《c# 扩展方法奇思妙用基础篇六：WhereIf 扩展》一文中的扩展方法予以简化：

1
2
3
4
5
6
7
8

public ActionResult Index2(string firstName, string lastName, DateTime? birthday, bool? sex) {
var employees = repository.Query()
.WhereIf(e => e.FirstName.Contains(firstName), firstName.IsNotNullAndEmpty())
.WhereIf(e => e.LastName.Contains(lastName), lastName.IsNotNullAndEmpty())
.WhereIf(e => e.Birthday.Value.Date == birthday.Value.Date, birthday.HasValue)
.WhereIf(e => e.Sex == sex, sex.HasValue);
return View("Index", employees);
}

代码相清晰了许多，我之前的几个 MVC 项目中也是这样处理的。

但时间一长，我逐步也发现了这种方式一些不足之处：

首先，网站中有很多类似的查询，如Customer、Order、Product 等等。而且大致也有点规律：字符串的一般模糊查询，时间日期类的一般按日期查询（忽略时间），其它类型则相等查询。不同 Model 查询的 Action 编码总有八、九分相似，但又不是简单的重复，却又难以重构。
需求变动，如增加一个查询条件，修改 View 是必须的，但也要修改 Action，增加一个参数，还要加一行 Where 或 WhereIf。简单变动却多处修改，烦人啊，而且这种需求变动又是比较频繁的，尤其是在项目初期。若能只修改 View 而不修改 Action 就爽了。
…

思考后，我决定使用 Expression Trees 作为查询 Action的参数来弥补这些不足。

使用 Expression<Func<T, bool>> 作为 Action 的参数

试看如下代码：

1
2
3
4

public ActionResult Index3(Expression<Func<Employee, bool>> predicate) {
var employees = repository.Query().Where(predicate);
return View("Index", employees);
}

我将 Expression Trees 作为 Action 的唯一的参数（暂不考虑分页、排序等），将所有的查询条件都统一汇集至 predicate 参数。

所有的查询（不管是 Employee 还是 Customer）都使用如上代码。其它实体查询只需修改参数的类型，如 Customer 查询改为 Expression<Func<Customer, bool>> 。

细心品味下，相信你能理解这种做法的精妙之处！

如上修改代码后，直接运行会报错，因为 MVC 中默认的数据绑定器 DefaultModelBinder 不能正确绑定 Expression<Func<T, bool>> 类型的参数。

我们要新创一个新的 ModelBinder。

创建 QueryConditionExpressionModelBinder

我们需要一个新的 ModelBinder 来为 Expression<Func<T, bool>> 类型的参数赋值，且命名为 QueryConditionExpressionModelBinder。

QueryConditionExpressionModelBinder 要根据上下文来自动生成查询的 Expression Trees。主要关注的上下文有两点：首先是当前 Model 的类型，即 typeof(T)；其次是 Request 提供的值，可通过 ValueProvider 获取。

下面给出一个粗略实现，仅用来说明这个思路是可行的：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

public class QueryConditionExpressionModelBinder : IModelBinder {
public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext) {
var modelType = GetModelTypeFromExpressionType(bindingContext.ModelType);
if (modelType == null) return null;

var body = default(Expression);
var parameter = Expression.Parameter(modelType, modelType.Name);

foreach (var property in modelType.GetProperties()){
var queryValue = GetValueAndHandleModelState(property, bindingContext.ValueProvider, controllerContext.Controller);
if (queryValue == null) continue;

Expression proeprtyCondition = null;
if (property.PropertyType == typeof (string)){
if (!string.IsNullOrEmpty(queryValue as string)){
proeprtyCondition = parameter
.Property(property.Name)
.Call("Contains", Expression.Constant(queryValue));
}
}
else if (property.PropertyType == typeof (DateTime?)){
proeprtyCondition = parameter
.Property(property.Name)
.Property("Value")
.Property("Date")
.Equal(Expression.Constant(queryValue));
}
else{
proeprtyCondition = parameter
.Property(property.Name)
.Equal(Expression.Constant(queryValue));
}
if (proeprtyCondition != null)
body = body != null ? body.AndAlso(proeprtyCondition) : proeprtyCondition;
}
if (body == null) body = Expression.Constant(true);
return body.ToLambda(parameter);
}
/// <summary>
/// 获取 Expression<Func<TXXX, bool>> 中 TXXX 的类型
/// </summary>
private Type GetModelTypeFromExpressionType(Type lambdaExpressionType) {

if (lambdaExpressionType.GetGenericTypeDefinition() != typeof (Expression<>)) return null;

var funcType = lambdaExpressionType.GetGenericArguments()[0];
if (funcType.GetGenericTypeDefinition() != typeof (Func<,>)) return null;

var funcTypeArgs = funcType.GetGenericArguments();
if (funcTypeArgs[1] != typeof (bool)) return null;
return funcTypeArgs[0];
}
/// <summary>
/// 获取属性的查询值并处理 Controller.ModelState
/// </summary>
private object GetValueAndHandleModelState(PropertyInfo property, IValueProvider valueProvider, ControllerBase controller) {
var result = valueProvider.GetValue(property.Name);
if (result == null) return null;

var modelState = new ModelState {Value = result};
controller.ViewData.ModelState.Add(property.Name, modelState);

object value = null;
try{
value = result.ConvertTo(property.PropertyType);
}
catch (Exception ex){
modelState.Errors.Add(ex);
}
return value;
}
}

了解这段代码，需要 MVC 和 Expression Trees 的一些知识。这段代码还用到了 Expression 扩展方法，参见：《c# 扩展方法奇思妙用基础篇九：Expression 扩展》。

如果不想在 Global.asax 文件中设置 Expression<Func<T, bool>> 的 ModelBinder，可以借助用下面这个 Attribute 类：

1
2
3
4
5

public class QueryConditionBinderAttribute : CustomModelBinderAttribute {
public override IModelBinder GetBinder() {
return new QueryConditionExpressionModelBinder();
}
}

Index3 简单修改如下：

1	public ActionResult Index3([QueryConditionBinder]Expression<Func<Employee, bool>> predicate) { //... }

下面是一个调试截图，绑定正常。

再次说明：本部分代码仅用来说明思路可行，用了大量的硬编码。

我也正在准备编写一个更加灵活 QueryConditionExpressionModelBinder，来应对复杂的查询（如时间范围、值大于、小于等、以及限制对某些属性的查询），目前也有了一个大体的思路，初步完成后在之后的博文中和大家分享下。如果你有好的思路，不妨写在回复中。

源码下载：MvcQuery.rar （VS2010 MVC3 项目，1758KB）

在线演示：http://asp-net-mvc-expression-trees-as-action-parameter.ldp.me

将 MVC 发挥到极致，是我的追求！

本文链接

c# 扩展方法奇思妙用基础篇九：Expression 扩展

2011-09-15T09:18:00Z

.net 中创建 Expression Trees 最简单的方式是使用 lambda 表达式：

1 2	Expression<Func<Person, bool>> exp = p => p.Name.Contains("ldp") && p.Birthday.Value.Year > 1990;

其中 Person 类定义如下：

1
2
3
4

public class Person {
public string Name { get; set; }
public DateTime? Birthday { get; set; }
}

但有些时候，要动态创建 Expression Trees，我们要用到 System.Linq.Expressions 命名空间中的 Expression 类。

使用 Expression 类中的静态方法，前面的 Expression Trees 可如下创建：

1
2
3
4
5
6
7
8
9
10

var parameter = Expression.Parameter(typeof(Person), "p");
var left = Expression.Call(
Expression.Property(parameter, "Name"),
typeof(string).GetMethod("Contains"),
Expression.Constant("ldp"));
var right = Expression.GreaterThan(
Expression.Property(Expression.Property(Expression.Property(parameter, "Birthday"), "Value"), "Year"),
Expression.Constant(1990));
var body = Expression.AndAlso(left, right);
var lambda = Expression.Lambda<Func<Person, bool>>(body, parameter);

你应该注意到第 7 行高亮部分，三个重复的 Expression.Property，显得非常臃肿，导致可读性也很差。

可以用下面几个扩展方法予以简化：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

public static class ExpressionExtensions {
public static Expression AndAlso(this Expression left, Expression right) {
return Expression.AndAlso(left, right);
}
public static Expression Call(this Expression instance, string methodName, params Expression[] arguments) {
return Expression.Call(instance, instance.Type.GetMethod(methodName), arguments);
}
public static Expression Property(this Expression expression, string propertyName) {
return Expression.Property(expression, propertyName);
}
public static Expression GreaterThan(this Expression left, Expression right) {
return Expression.GreaterThan(left, right);
}
public static Expression<TDelegate> ToLambda<TDelegate>(this Expression body, params ParameterExpression[] parameters) {
return Expression.Lambda<TDelegate>(body, parameters);
}
}

这五个扩展方法相当简单，没什么技术含量。可以根据自己需要，添加更多的扩展方法。

前面的代码简化成：

1
2
3
4

var parameter = Expression.Parameter(typeof(Person), "p");
var left = parameter.Property("Name").Call("Contains", Expression.Constant("ldp"));
var right = parameter.Property("Birthday").Property("Value").Property("Year").GreaterThan(Expression.Constant(1990));
var lambda = left.AndAlso(right).ToLambda<Func<Person, bool>>(parameter);

是不是好多了。

简单编码，快乐生活！

《c#扩展方法奇思妙用》系统文章从 2009 年 08 月开始写起，到现在一共有了 24 篇，欢迎阅读：

基础篇：	中文处理、string 常用扩展、byte 常用扩展、Random 扩展、Dictionary<TKey, TValue> 扩展、WhereIf 扩展、IsBetween 通用扩展、WhereIf 扩展、Distinct 扩展
高级篇：	改进 Scottgu 的 "In" 扩展、Aggregate扩展其改进、Enumerable.Cast<T>应用、对扩展进行分组管理、ToString(string format) 扩展、WinForm 控件选择器、树”通用遍历器、Type类扩展
变态篇：	由Fibonacci数列引出“委托扩展”及“递推递归委托”、封装 if/else、swith/case及while、switch/case 组扩展、string 的翻身革命
性能篇：	扩展方法性能初测
MVC篇：	巧用扩展方法优先级，美化所有页面TextBoxFor文本框

本文链接

博客园_鹤冲天

c# 扩展方法 奇思妙用 高级篇 九：OrderBy(string propertyName, bool desc)

Linq：切勿使用 Count() > 0 来判断集合非空

c# 扩展方法奇思妙用基础篇十：IsEmpty、IsNotEmpty 扩展

四行代码创建复杂（无限级）树

ASP.NET MVC：自定义 Route 让你的 Url 更优雅

你能指出这个 ForEach 扩展方法中的错误吗？

复用 Entity Framework 中英语单复数形式变换的类

ASP.NET MVC：Expression Trees 作为参数简化查询 二

ASP.NET MVC：Expression Trees 作为参数简化查询

c# 扩展方法奇思妙用基础篇九：Expression 扩展

c# 扩展方法奇思妙用高级篇九：OrderBy(string propertyName, bool desc)

ASP.NET MVC：Expression Trees 作为参数简化查询二