.NET 动态lambda表达式（2）

       上一篇博客介绍了基本的动态方法，这篇总结一下帮助类和使用方法，帮助类：

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Runtime.Serialization.Formatters.Binary;
using System.Web;
using System.Xml.Serialization;

namespace Demo.Helper
{
    [Serializable]
    public class LamadaExtention<Dto> where Dto : new()
    {
        public LamadaExtention<Dto> Clone2() //深clone
        {
            LamadaExtention<Dto> model = new LamadaExtention<Dto>();
            model.m_lstExpression = new List<Expression>(m_lstExpression);
            model.m_Parameter = m_Parameter;
            return model;
        }

        public List<Expression> m_lstExpression = null;
        public ParameterExpression m_Parameter = null;

        public LamadaExtention()
        {
            m_lstExpression = new List<Expression>();
            m_Parameter = Expression.Parameter(typeof(Dto), "x");
        }

        //构造表达式，存放到m_lstExpression集合里面
        public void GetExpression(string strPropertyName, object strValue, ExpressionType expressType)
        {
            Expression expRes = null;
            MemberExpression member = Expression.PropertyOrField(m_Parameter, strPropertyName);
            if (expressType == ExpressionType.Contains)
            {
                expRes = Expression.Call(member, typeof(string).GetMethod("Contains"), Expression.Constant(strValue));
            }
            else if (expressType == ExpressionType.Equal)
            {
                expRes = Expression.Equal(member, Expression.Constant(strValue, member.Type));
            }
            else if (expressType == ExpressionType.LessThan)
            {
                expRes = Expression.LessThan(member, Expression.Constant(strValue, member.Type));
            }
            else if (expressType == ExpressionType.LessThanOrEqual)
            {
                expRes = Expression.LessThanOrEqual(member, Expression.Constant(strValue, member.Type));
            }
            else if (expressType == ExpressionType.GreaterThan)
            {
                expRes = Expression.GreaterThan(member, Expression.Constant(strValue, member.Type));
            }
            else if (expressType == ExpressionType.GreaterThanOrEqual)
            {
                expRes = Expression.GreaterThanOrEqual(member, Expression.Constant(strValue, member.Type));
            }
            //return expRes;
            m_lstExpression.Add(expRes);
        }

        //针对Or条件的表达式
        public void GetExpression(string strPropertyName, List<object> lstValue)
        {
            Expression expRes = null;
            MemberExpression member = Expression.PropertyOrField(m_Parameter, strPropertyName);
            foreach (var oValue in lstValue)
            {
                if (expRes == null)
                {
                    expRes = Expression.Equal(member, Expression.Constant(oValue, member.Type));
                }
                else
                {
                    expRes = Expression.Or(expRes, Expression.Equal(member, Expression.Constant(oValue, member.Type)));
                }
            }


            m_lstExpression.Add(expRes);
        }

        //得到Lamada表达式的Expression对象
        public Expression<Func<Dto, bool>> GetLambda()
        {
            Expression whereExpr = null;
            foreach (var expr in this.m_lstExpression)
            {
                if (whereExpr == null) whereExpr = expr;
                else whereExpr = Expression.And(whereExpr, expr);
            }
            if (whereExpr == null)
                return null;
            return Expression.Lambda<Func<Dto, Boolean>>(whereExpr, m_Parameter);
        }
        
    }

    //用于区分操作的枚举
    public enum ExpressionType
    {
        Contains,//like
        Equal,//等于
        LessThan,//小于
        LessThanOrEqual,//小于等于
        GreaterThan,//大于
        GreaterThanOrEqual//大于等于
    }
}

       测试使用方法：

public ActionResult DyList2(string ColName, string Value)
{
    var lstRes = new List<PerSon>();
    for (var i = 0; i < 10; i++)
    {
        var oModel = new PerSon();
        oModel.Age = i;
        oModel.Name = "测试" + i.ToString();
        oModel.Type = i % 3;
        lstRes.Add(oModel);
    } 
    var oLamadaExtention = new LamadaExtention<PerSon>();
    //这里也可以根据需要传入等于等条件
    oLamadaExtention.GetExpression(ColName, Value, BusinessBureau.Helper.ExpressionType.Contains);
    var le = lstRes.Where(oLamadaExtention.GetLambda().Compile()).ToList<PerSon>();
    return View();
}

        结果：