表达树的实际用法

Question

表达树是一个很好的功能，但它的实际用途是什么？他们可以用于某种代码生成或元编程或某些类似的？

Answer 1

您可以使用它们为Google或Flickr或Amazon等网站，您自己的网站或其他数据提供商构建自己的linq提供程序。

Answer 2

Marc Gravell用MiscUtil来实现generic operators的效果很好。

Answer 3

LINQ提供程序的实现主要通过处理表达式树来完成。我还使用他们从我的代码删除文字字符串：

• Monorail
• NHibernate

Answer 4

由于乔恩指出，我用它们来提供generic operators使用.NET 3.5。我也使用它们（再次在MiscUtil中）提供对非默认构造函数的快速访问（不能使用Delegate.CreateDelegate和构造函数，但Expression工作正常）。

的手动创建的表达式树的其他用途：

• object cloning
• dynamic LINQ sorting
• as a compiler

不过说真的，表情写任何的动态代码非常灵活的方式。比Reflection.Emit简单得多，而且我的钱比CodeDOM更容易理解。而在.NET 4.0中，您有even more options可用。我通过Expressionon my blog显示编写代码的基本原理。

Answer 5

我使用它们来创建动态查询，无论是用于排序还是过滤数据。举个例子：

IQueryable<Data.Task> query = ctx.DataContext.Tasks; 

if (criteria.ProjectId != Guid.Empty) 
     query = query.Where(row => row.ProjectId == criteria.ProjectId); 

if (criteria.Status != TaskStatus.NotSet) 
     query = query.Where(row => row.Status == (int)criteria.Status); 

if (criteria.DueDate.DateFrom != DateTime.MinValue) 
     query = query.Where(row => row.DueDate >= criteria.DueDate.DateFrom); 

if (criteria.DueDate.DateTo != DateTime.MaxValue) 
    query = query.Where(row => row.DueDate <= criteria.DueDate.DateTo); 

if (criteria.OpenDate.DateFrom != DateTime.MinValue) 
    query = query.Where(row => row.OpenDate >= criteria.OpenDate.DateFrom); 

var data = query.Select(row => TaskInfo.FetchTaskInfo(row)); 

Answer 6

最初由Jomo Fisher，Gustavo Guerra公布的 的static string dictionary的修订版。

其中通过表达式树，一个动态表达式，提供一个真正的（读：可笑）字典。

该实现创建一个动态决策树，根据输入字符串的长度选择corrent值，然后按第一个字母，然后第二个字母等等。

这最终运行得比等效词典快得多。

Answer 7

我用表达式树建立一个数学表达式求值：Building Expression Evaluator with Expression Trees in C#

Answer 8

我只是用ExpressionTree创建generic filter function ..我想share和你们一样...

Start

var allFiltered= Filter(AllCustomer, "Name", "Moumit"); 

public static List<T> Filter<T>(this List<T> Filterable, string PropertyName, object ParameterValue) 
{ 
    ConstantExpression c = Expression.Constant(ParameterValue); 
    ParameterExpression p = Expression.Parameter(typeof(T), "xx"); 
    MemberExpression m = Expression.PropertyOrField(p, PropertyName); 
    var Lambda = Expression.Lambda<Func<T, Boolean>>(Expression.Equal(c, m), new[] { p }); 
    Func<T, Boolean> func = Lambda.Compile(); 
    return Filterable.Where(func).ToList(); 
} 

One More

string singlePropertyName=GetPropertyName((Property.Customer p) => p.Name); 

public static string GetPropertyName<T, U>(Expression<Func<T, U>> expression) 
{ 
     MemberExpression body = expression.Body as MemberExpression; 
     // if expression is not a member expression 
     if (body == null) 
     { 
      UnaryExpression ubody = (UnaryExpression)expression.Body; 
      body = ubody.Operand as MemberExpression; 
     } 
     return string.Join(".", body.ToString().Split('.').Skip(1)); 
} 

Make it more expandable

string multiCommaSeparatedPropertyNames=GetMultiplePropertyName<Property.Customer>(c => c.CustomerId, c => c.AuthorizationStatus) 

public static string GetMultiplePropertyName<T>(params Expression<Func<T, object>>[] expressions) 
{ 
     string[] propertyNames = new string[expressions.Count()]; 
     for (int i = 0; i < propertyNames.Length; i++) 
     { 
      propertyNames[i] = GetPropertyName(expressions[i]); 
     } 

     return propertyNames.Join(); 
} 

.......我知道它也可以用Reflection做......但是这一个是巨大的快或我可以说相当于第一次编译后的...第一次迭代只是平均10毫秒慢...所以这是Expression Tree的魔法。简单而美妙....我想...... !!!!!!!!