c#——表达式树在LINQ动态查询

一般如果逻辑比较简单，只是存在有的情况多一个查询条件，有的情况不需要添加该查询条件

简单方式这样操作就可以了

public IQueryable<FileImport> DynamicChainedSyntax
		(IQueryable<FileImport> files, bool pastOnly)
{
	var query = files.Where(file => file.ImportDate >
				DateTime.Now.AddDays(-7));
	if (pastOnly)
		query = query.Where(file => file.ImportDate <
				DateTime.Today);
	return query;
}

这里的多个where条件是AND关系，如果是OR的关系，可将多次查询的结果进行union

当然大多数的时候，我们是希望能够动态构建查询条件的，你可以针对任何字段进行任何操作符形式的查询，不同查询条件之间的关系也是可以动态定义的。

这时候表达式树就派上用场了，关于表达式树的基础知识已经在上一篇中提到了。

这里主要说如何构建linq中Where查询条件，其实只是熟悉表达式树的其他提供的方法，非常简单。

public Func<TSource, bool> SimpleComparison<TSource>			
			string property, object value)
{
	var type = typeof (TSource);
	var pe = Expression.Parameter(type, "p");
	var propertyReference = Expression.Property(pe, property);
	var constantReference = Expression.Constant(value);
	return Expression.Lambda<Func<TSource, bool>>
		(Expression.Equal(propertyReference, constantReference),
		new[] { pe }).Compile();
}

呵呵，话到这里，看看我的小DEMO

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            //(a,b)=>(a+b)
            //参数的构建  (定义参数的名字和参数的类型)
            ParameterExpression exp1 = Expression.Parameter(typeof(int), "a");
            ParameterExpression exp2 = Expression.Parameter(typeof(int), "b");
            //表达式主体的构建 
            BinaryExpression exp = Expression.Add(exp1, exp2);
            //表达式树的构建（如下定义，表达式的类型为Lambda 
            //lambda表达式的类型为Func<int, int, int>）
            var lambda = Expression.Lambda<Func<int, int, int>>(exp, exp1, exp2);

            //p=>p.Name 可以动态构建OrderBy
            ParameterExpression exp3 = Expression.Parameter(typeof(Person), "p");
            var property = Expression.Property(exp3, "Name");
            var lambda2 = Expression.Lambda<Func<Person, string>>(property, exp3);

            //p=>p.Name == "daisy" 
            List<Person> persons = new List<Person>() 
            { new Person(){ Name = "daisy", age = 10 },
              new Person(){ Name = "daisy", age = 12 }, 
              new Person(){Name="dom", age=12},
              new Person(){Name="caren", age=10}};
            var compareExp = simpleCompare<Person>("Name", "daisy");
            var daisys = persons.Where(compareExp).ToList();
            foreach (var item in daisys)
            {
                Console.WriteLine("Name:  "+item.Name+"    Age:  "+item.age);
            }
            Console.ReadKey();
        }
        public static Func<TSource, bool> simpleCompare<TSource>(string property, object value)
        {
            var type = typeof(TSource);
            var pe = Expression.Parameter(type, "p");
            var propertyReference = Expression.Property(pe, property);
            var constantReference = Expression.Constant(value);

            //compile 是表达式的一个接口，生成该lambda表达式树对的委托
            return Expression.Lambda<Func<TSource, bool>>(Expression.Equal(propertyReference, constantReference), pe).Compile();
        }

    }
    public class Person
    {
        public string Name { get; set; }
        public int age { get; set; }
    }
}

再来看看查询结果：

嗯，理解起来还是非常简单的，就是构建表达式树，返回我们需要的委托类型！

接下来猛料哦

动态构建表达式树，最佳实践版，很实用！

 public class FilterCollection : Collection<IList<Filter>>
    {
        public FilterCollection()
            : base()
        { }
    }

    public class Filter
    {
        public string PropertyName { get; set; }
        public Op Operation { get; set; }
        public object Value { get; set; }
    }

    public enum Op
    {
        Equals,
        GreaterThan,
        LessThan,
        GreaterThanOrEqual,
        LessThanOrEqual,
        Contains,
        StartsWith,
        EndsWith
    }

通过上面的类可以动态构建复杂的查询条件，下面具体调用的类哦

using Infrastructure.Model;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;

namespace Infrastructure.Operation
{
    public static class LambdaExpressionBuilder
    {
        private static MethodInfo containsMethod = typeof(string).GetMethod("Contains");
        private static MethodInfo startsWithMethod =
                                typeof(string).GetMethod("StartsWith", new Type[] { typeof(string) });
        private static MethodInfo endsWithMethod =
                                typeof(string).GetMethod("EndsWith", new Type[] { typeof(string) });
        private static Expression GetExpression(ParameterExpression param, Filter filter)
        {
            MemberExpression member = Expression.Property(param, filter.PropertyName);
            Expression handledMember = member;
            ConstantExpression constant = Expression.Constant(filter.Value);

            if (member.Member.MemberType == MemberTypes.Property)
            {
                Type propertyType = ((PropertyInfo)member.Member).PropertyType;
                if (propertyType == typeof(string))
                {
                    handledMember = Expression.Call(member, typeof(string).GetMethod("ToLower", System.Type.EmptyTypes));
                }
                if (propertyType == typeof(DateTime?))
                {
                    handledMember = Expression.Property(member, typeof(DateTime?).GetProperty("Value"));
                }
            }

            switch (filter.Operation)
            {
                case Op.Equals:
                    return Expression.Equal(handledMember, constant);
                case Op.GreaterThan:
                    return Expression.GreaterThan(handledMember, constant);
                case Op.GreaterThanOrEqual:
                    return Expression.GreaterThanOrEqual(handledMember, constant);
                case Op.LessThan:
                    return Expression.LessThan(handledMember, constant);
                case Op.LessThanOrEqual:
                    return Expression.LessThanOrEqual(handledMember, constant);
                case Op.Contains:
                    return Expression.Call(handledMember, containsMethod, constant);
                case Op.StartsWith:
                    return Expression.Call(handledMember, startsWithMethod, constant);
                case Op.EndsWith:
                    return Expression.Call(handledMember, endsWithMethod, constant);
            }

            return null;
        }
        private static BinaryExpression GetORExpression(ParameterExpression param, Filter filter1, Filter filter2)
        {
            Expression bin1 = GetExpression(param, filter1);
            Expression bin2 = GetExpression(param, filter2);

            return Expression.Or(bin1, bin2);
        }

        private static Expression GetExpression(ParameterExpression param, IList<Filter> orFilters)
        {
            if (orFilters.Count == 0)
                return null;

            Expression exp = null;

            if (orFilters.Count == 1)
            {
                exp = GetExpression(param, orFilters[0]);
            }
            else if (orFilters.Count == 2)
            {
                exp = GetORExpression(param, orFilters[0], orFilters[1]);
            }
            else
            {
                while (orFilters.Count > 0)
                {
                    var f1 = orFilters[0];
                    var f2 = orFilters[1];

                    if (exp == null)
                    {
                        exp = GetORExpression(param, orFilters[0], orFilters[1]);
                    }
                    else
                    {
                        exp = Expression.Or(exp, GetORExpression(param, orFilters[0], orFilters[1]));
                    }
                    orFilters.Remove(f1);
                    orFilters.Remove(f2);

                    if (orFilters.Count == 1)
                    {
                        exp = Expression.Or(exp, GetExpression(param, orFilters[0]));
                        orFilters.RemoveAt(0);
                    }
                }
            }

            return exp;
        }

        public static Expression<Func<T, bool>> GetExpression<T>(FilterCollection filters)
        {
            if (filters == null || filters.Count == 0)
                return null;

            ParameterExpression param = Expression.Parameter(typeof(T), "t");
            Expression exp = null;

            if (filters.Count == 1)
            {
                exp = GetExpression(param, filters[0]);
            }
            else if (filters.Count == 2)
            {
                exp = Expression.AndAlso(GetExpression(param, filters[0]), GetExpression(param, filters[1]));
            }

            else
            {
                while (filters.Count > 0)
                {
                    var f1 = filters[0];
                    var f2 = filters[1];
                    var f1Andf2 = Expression.AndAlso(GetExpression(param, filters[0]), GetExpression(param, filters[1]));
                    if (exp == null)
                    {
                        exp = f1Andf2;
                    }
                    else
                    {
                        exp = Expression.AndAlso(exp, f1Andf2);
                    }

                    filters.Remove(f1);
                    filters.Remove(f2);

                    if (filters.Count == 1)
                    {
                        exp = Expression.AndAlso(exp, GetExpression(param, filters[0]));
                        filters.RemoveAt(0);
                    }
                }
            }

            return Expression.Lambda<Func<T, bool>>(exp, param);
        }
    }
}

再来一个OrderBy动态构建

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Text;

namespace Jurassic.Sooil.Com
{
    public static class OrderExpression
    {
        public static IOrderedQueryable<T> OrderBy<T>(this IQueryable<T> source, string property)
        {
            return ApplyOrder<T>(source, property, "OrderBy");
        }
        public static IOrderedQueryable<T> OrderByDescending<T>(this IQueryable<T> source, string property)
        {
            return ApplyOrder<T>(source, property, "OrderByDescending");
        }
        public static IOrderedQueryable<T> ThenBy<T>(this IOrderedQueryable<T> source, string property)
        {
            return ApplyOrder<T>(source, property, "ThenBy");
        }
        public static IOrderedQueryable<T> ThenByDescending<T>(this IOrderedQueryable<T> source, string property)
        {
            return ApplyOrder<T>(source, property, "ThenByDescending");
        }
        static IOrderedQueryable<T> ApplyOrder<T>(IQueryable<T> source, string property, string methodName)
        {
            string[] props = property.Split('.');
            Type type = typeof(T);
            ParameterExpression arg = Expression.Parameter(type, "x");
            Expression expr = arg;
            foreach (string prop in props)
            {
                // use reflection (not ComponentModel) to mirror LINQ
                PropertyInfo pi = type.GetProperty(prop);
                expr = Expression.Property(expr, pi);
                type = pi.PropertyType;
            }
            Type delegateType = typeof(Func<,>).MakeGenericType(typeof(T), type);
            LambdaExpression lambda = Expression.Lambda(delegateType, expr, arg);

            object result = typeof(Queryable).GetMethods().Single(
                    method => method.Name == methodName
                            && method.IsGenericMethodDefinition
                            && method.GetGenericArguments().Length == 2
                            && method.GetParameters().Length == 2)
                    .MakeGenericMethod(typeof(T), type)
                    .Invoke(null, new object[] { source, lambda });
            return (IOrderedQueryable<T>)result;
        } 
    }
}

至此动态构建LINQ查询结束！花了上班时间一上午，还是相当值得的，不过被项目经理知道了得哭死！

不管如何，学到手的才是自己的！