关于LINQ 和lambda表达式

一LINQ :    既可以实现过滤数据（和lambda一样）也可以实现查找其他类型数据的功能 LINQ表达式的from行可以嵌套  实现表多层关联一层层向下找的目的  (注意一对一还是一对多的对应关系 容易乱  别把上层过滤掉的内容又关联回来了)   过滤完要ToList() 不然是IQueryable类型

   var actionList= from r in userInfo.RoleInfo     //等号前后类型不一样  把用户类型变成角色类型又变成权限类型了（通过导航属性）
         from a in r.ActionInfo
         where a.ActionTypeEnum == actionTypeEnum
         select a;                                                

二 lambda ：

 动态拼接：  原文地址 http://www.cnblogs.com/green-4984/archive/2012/02/22/2362614.html

作为Delegate的更进一步的应用，Lambda让我们的代码更加的简介与方便，可以方便的用Where（）、Select（）等扩展方法对集合进行筛选，组合。但同时也遇到了一个问题，有时候，因为用户想要进行的条件并不是固定不便的，有时候会这么查，有时候又会组合查，同时，有时候因为数据库设计的原因，有的字段拼接成一个很长的字符串，但是这时又要进行查询，只要与条件有交集，那么就要提取出这条记录，所以必须要用到动态构建Lambda表达式。

但是作为一种静态语言，我们显然无法用动态语法或者拼接字符串的方式来创建一个Delegate/Lambda，那么如何才能达到类似的目的呢？或许最佳的选择就是表达式树。  

我们都知道Lambda的样子是这样的

      i = > i < 5

在这个Lambda表达式中，i被成为Parameter，< 叫做操作符，以及一个常数 5，这样就构建了一个Lambda表达式，那么MS专门提供了一些类来让我们可以手工创建。

首先需要引入命名空间

using System.Linq.Expressions.Expression;

创建一个数组用来当做例子

var ints = new int []{ 1, 2 , 3 , 4 , 5 , 6 };

// 要创建形如 i => i < 5

 

//创建参数 i

var parameter  = Expression.Parameter(typeof(int),”i”);

//创建常数 5

var constant = Expression.Constant(5);

//创建 i > 5

var bin = Expression.GreaterThan(parameter,constant);

//获取Lambda表达式

var lambda=Expression.Lambda<Func<Int32,Boolean>>(bin,parameter);

//取得查询结果

var query = ints.Where(lambda.Compile());

 

到这里就完成了一次结果的查询，此时在程序中通过下断点的方式来查看我们构造的表达式是否正确。

 

 

接下来创建更加复杂一些的表达式

BinaryExpression condition = null;

//要构造的表达式i==1||i==2||i==3.....

for (int i = 0; i < ints.Length; i++)

{

      ConstantExpression ce = Expression.Constant(i);

      if (condition == null)

      {

           condition = Expression.Equal(parameter, ce);

      }

      else

      {

           var right = Expression.Equal(parameter, ce);

           condition = Expression.Or(condition, right);

      }

}

Expression<Func<Int32, Boolean>> lambda = Expression.Lambda<Func<Int32, Boolean>>(condition, parameter);

 

因为现在用实体类，那么如果是实体类进行构造的话需要这样来做

 

//p => p.Name == "1" && p.Address == "2"

            ParameterExpression parameter1 = Expression.Parameter(typeof(Person), "p");

            ConstantExpression constant1 = Expression.Constant("1");

            ConstantExpression constant2 = Expression.Constant("1");

            MemberExpression member = Expression.PropertyOrField(parameter1, "Name");

            var query1 = Expression.Equal(member, constant1);

            var query2 = Expression.Equal(Expression.PropertyOrField(parameter1, "Address"), constant2);

            var query = Expression.And(query1, query2);

            var lambda1 = Expression.Lambda<Func<Person, Boolean>>(query, parameter1);

            var list = MethodExtend.GetUser(lambda1.Compile());

  工具扩展类： 原文：http://www.cnblogs.com/Lau7/p/5451985.html

public static class ExpressionExt
{
    public static Expression<Func<T, bool>> And<T>(this Expression<Func<T, bool>> expr1, Expression<Func<T, bool>> expr2)
    {          
        return Expression.Lambda<Func<T, bool>>(Expression.AndAlso(expr1.Body, expr2.Body), expr1.Parameters);
    }
    public static Expression<Func<T, bool>> Or<T>(this Expression<Func<T, bool>> expr1,Expression<Func<T, bool>> expr2)
    {
        return Expression.Lambda<Func<T, bool>>(Expression.OrElse(expr1.Body, expr2.Body), expr1.Parameters);
    }
}

　　上面这代码是我们这文章的核心，我在这里顺便解释一下这个And扩展方法它是怎么做的，它这里先是使用Expression类中的静态方法AndAlso把expr1和expr2的主体拼接在一起，如果AndAlso方法返回的是BinaryExpression类型的结果，而dapperLambda的条件参数需要的是Lambda表达式树，所以这里我们需要通过Expression.Lambda方法来构造一个委托类型来创建一个Lambda表达树。

　　那现在我们通过上面的扩展方法，再来优化一下我们最初举的例子看下：

Expression<Func<SysUser, bool>> exp1 = s => s.UserName.Contains("1") && s.Age > 0;
Expression<Func<SysUser, bool>> exp2 =exp1.And( s => s.IsEnable == 1);
using (var context = new DbContext().ConnectionString(connString))
{
    var result1 = context.Select<SysUser>(exp1).QueryMany();
    var result2 = context.Select<SysUser>(exp2).QueryMany();
}

 对于过滤前后类型一样的情况可以使用  仅仅起过滤作用 不改变类型 过滤完要ToList() 不然是IQueryable类型

var userMenuActionList = userActionList.Where(a => a.ActionTypeEnum == actionTypeEnum).ToList();                 //等号前后类型一样