Linq to Sql：N层应用中的查询(下) : 根据条件进行动态查询

    如果允许在UI层直接访问Linq to Sql的DataContext，可以省去很多问题，譬如在处理多表join的时候，我们使用var来定义L2S查询，让编译器自动推断变量的具体类型(IQueryable<匿名类型>)，并提供友好的智能提示；而且可以充分应用L2S的延迟加载特性，来进行动态查询。但如果我们希望将业务逻辑放在一个独立的层中(譬如封装在远程的WCF应用中)，又希望在逻辑层应用Linq to sql，则情况就比较复杂了；由于我们只能使用var(IQueryable<匿名类型>)，而var只能定义方法(Method)范围中声明的变量，出了方法(Method)之后IDE就不认得它了；在这种对IQueryable<匿名类型>一无所知的情况下，又希望能在开发时也能应用上IDE的智能感应，我们该怎么定义层之间交互的数据传输载体呢？又如何对它进行动态查询呢？

     内容比较多，分上下两篇，上篇了介绍查询返回自定义实体，本篇介绍动态查询。

 

     在我们的日常开发中，时常需要根据用户在UI上的输入来进行动态查询。在Ado.Net主宰的旧石器时代，一般会这样来动态拼接SQL查询条件：

   1: string filter = " 1=1";

   2: if(XXOO文本框不为空)

   3:     filter += string.Format(" AND XXOO='{0}', XXOO)";

   4: if(OOXX文本框不为空)

   5:     filter += string.Format(" AND OOXX='{0}', OOXX)";

   6: gridView.DataSource = BusinessLogic.XOXOQuery(filter);

    然后将过滤条件传给业务逻辑层，由业务逻辑层拼接出完整的TSQL语句。  但到了LINQ to SQL时代，我们该办了呢？还要继续玩字符串拼接游戏吗？

    后面将以NorthWind为例，动态查询产品(Product)及其供应商信息(Supplier)：

   1: partial class ProductExt : Products

   2: {

   3:     public string CompanyName { get; set; }

   4: }

 

1. UI层直接访问DataContext

    如果使用L2S查询延迟加载的特性，动态查询也变得相当简单：

   1: public void TestDynamicQuery()

   2: {

   3:     using (NorthWindDataContext context = new NorthWindDataContext())

   4:     {

   5:         var query = from P in context.Products

   6:                            join S in context.Suppliers

   7:                             on P.SupplierID equals S.SupplierID

   8:                            select new

   9:                            {

  10:                                P.ProductName,

  11:                                P.UnitPrice,

  12:                                P.QuantityPerUnit,

  13:                                S.CompanyName

  14:                            };

  15:         if(XXOO)

  16:             query = query.Where(p => p.ProductName.Contains("che"));

  17:         if(OOXX)

  18:             query = query.Where(p => p.UnitPrice >= 20);

  19:         gridView.DataSource = query.ToList(); //延迟加载，ToList时才进行运算

  20:         gridView.DataBind();

  21:     }

  22: }

    看起来还是比较舒服的，不用再继续拼接SQL了，开发时也可以充分利用IDE的智能感应。

    但也不是无可挑剔，这里的逻辑无法复用。假如另外一个应用场景，要根据供应商名称来查询产品信息，我们该怎么处理呢，另外再写一个查询？如果再多一个引用场景呢，难道我们每次都要Ctrl+C | Ctrl +V？还是把这个逻辑封装在业务逻辑层，让多个的页面都可以使用？

 

2. 分层后引发的问题

    分层的好处之一就是逻辑复用。在Ado.Net时代，我们可以把这个join操作放在业务逻辑层，UI层只需要根据不同的应用场景，拼接where条件，然后传给业务逻辑层处理即可。

    当在分层应用中使用L2S时，如果想把这个逻辑放到业务逻辑层，我们或许可以这样做：

2.1.  继续拼接

    或许我们想过继续按照旧石器时代的做法，直接拼接；但是我们立刻会发现显然是行不通的，我们无法“直接”将L2S查询与字符串进行拼接。

2.2. 构造Expression或者Func

    query.Where()可以接受一个表达式Expression<Func<TSource, bool> predicate>或者委托Func<TSource, bool> predicate，或许我们想过尝试构造这样的Expression或者Func；但是我们又会遇到新的问题，如上面的查询，我们的query的类型是IQueryable<匿名类型>，匿名类型的定义是在编译阶段才由编译器创建的，开发时我们根本不知道TSource是类型，又该怎么创建这样的Expression或者Func呢？

 

3. 使用Dynamic LINQ继续拼接游戏

    上面2.1中提到无法“直接”将L2S查询与字符串进行拼接，但是可以通过一些扩展来间接达到目的，网上已经有人这么做了，具体可以参考：Dynamic LINQ。下面是一个示例：

   1: Northwind db = new Northwind(connString); 

   2: var query =

   3:     db.Customers.Where("City == @0 and Orders.Count >= @1", "London", 10).

   4:     OrderBy("CompanyName").

   5:     Select("New(CompanyName as Name, Phone)");

    看起来，貌似我们又可以继续玩字符串拼接了。不过需要注意的一点儿是，这里拼接的字符串不再是TSQL中的字符串命令了，而是L2S查询。这是基于如下原因：在L2S中，查询被表示为一个表达式目录树(Expression Tree，表示的是数据，不是代码)，待需要访问查询结果集时(针对延迟加载的情况)，这棵树才被对应的Provider(这里用的是SQL Server，所以对应的是SqlProvider)翻译为TSQL，并发送给ADO.Net来执行；Dynamic LINQ就是将传进来的字符串解析为表达式目录树，并与原来的L2S进行适当地合并，从而得到最终的表达式目录树。

    根据字符串进行拼接，是一种解决办法。但是这样做有个不好的地方，就是我们失去了IDE的智能感应。

 

4. 对IQueryable进行动态查询扩展

    上面2.2节中，还提到了另外一种处理思路，那就是构造Expression或者Func；当然，这里会遇到上面提到的问题：我们的query的类型是IQueryable<匿名类型>，开发时根本不知道其具体类型，如何创建Expression<Func<匿名类型, bool> predicate>或者委托Func<匿名类型, bool> predicate呢？

   下面是我实现过程中的那艰苦卓越的辛酸历程：

    还是拿上面的查询作为例子，譬如要查询ProductName.Contains("che")) && UnitPrice >= 20的记录；则我们能构造出来的及需要构造出来的表达式会是什么样子呢？下面是两者之间的差距：

Expression<Func<Products, bool>> predicate = t => t.ProductName.Contains("che") && t.UnitPrice >= 22 //Can Do

Expression<Func<匿名类型, bool>> predicate = t => t.ProductName.Contains("che") && t.UnitPrice >= 22 //To DO

    差距呢？乍一看，这就是一对双胞胎啊，还需要转换个啥子，吃饱撑的啊……
    不过细看之后，二者确有不同之处，下面是补全后的对比：

Expression<Func<Products, bool>> predicate = (Products t) => t.ProductName.Contains("che") && t.UnitPrice >= 22

Expression<Func<匿名类型, bool>> predicate = (匿名类型 t) => t.ProductName.Contains("che") && t.UnitPrice >= 22

    现在可以看到，这不是一对普通的双胞胎，基因中的软色体都不是一个样子，这是一对龙凤胎。由于.Net是强类型语言，IEnumerable<TSource>.Where()方法只认得后者，而拒绝接受前者，因此接下来，我们的目标是……没有蛀牙？NO，基因手术……当然，也希望手术的副作用包括没有蛀牙(bug)。

 

                                      ------------------我是华丽的分割线(happyhippy.cnblogs.com)--------------------

 

    上一篇中，我实现了一个对象转换器，可以把一个对象转换成另一个对象；但这里用不上，这里需要换的是基因，需要把一种类型换成另一种类型。所以需要急切实现的一个函数就是，能把一个LambdaExpression的参数类型换成另一种类型，于是我实现了下面的方法：（其中，TSource为源类型，TResult为目标类型）

public static Expression<Func<TResult, bool>> Replace<TSource, TResult>( 

    this Expression<Func<TSource, bool>> predicate)

{

    ParameterConverter pc = new ParameterConverter(predicate);

    return (Expression<Func<TResult, bool>>)pc.Replace(typeof(TResult));

}

    在开始写这段代码之前，我的表达式目录树知识几乎为0；于是又开始翻MSDN，找到了这里：LINQ 中的表达式目录树……最终在MSDN的帮助下，我终于把它给实现出来了，完成后我不禁沾沾自喜(虽然只有几十行代码，可行代码不到十来行，剩下的是从MSDN中的ExpressionVisitor盗版的，但也耗了我整整一个半天)……

    古人云：乐极生悲。看来这句话还是有道理的。庆幸之后，接着我又坠入了万丈深渊，因为我不知道怎么调用这个方法！在这个方法外部，我们的query是IQueryable<匿名类型>，在IQueryable<匿名类型>.Where()方法中，尝试调用这个Replace方法的时候，我不知道该传什么类型参数给TResult。我又白干了……

 

    有时候，看起来只有一步之遥，但其实天各一方……

                                      ------------------我是可耻的分割线(happyhippy.cnblogs.com)--------------------

    有时候，看起来貌似遥不可及，但其实近在咫尺……

 

    前面提到：在L2S中，查询被表示为一个表达式目录树(Expression Tree，表示的是数据，不是代码)。我既然可以向上面这样修改Expression<Func<TSource, bool>>，那我应该也可以修改这个这个LINQ查询，而且Dynamic LINQ也正是在修改LINQ查询啊。

    看了下Dynamic LINQ中对Where的扩展，才知道IQueryable公布了其Provider属性：IQueryable.Provider，我们可可以直接调用Provider.CreateQuery来对原有的query进行扩充：

Expression<Func<Products, bool>> predicate = t => t.ProductName.Contains("che") && t.UnitPrice >= 22;

IQueryable query = from P in context.Products

                   join S in context.Suppliers

                   on P.SupplierID equals S.SupplierID

                   select new

                   {

                       P.ProductName,

                       P.UnitPrice,

                       P.QuantityPerUnit,

                       S.CompanyName

                   };

query = query.Provider.CreateQuery(

    Expression.Call(

        typeof(Queryable), "Where",

        new Type[] { query.ElementType }, 

        query.Expression, predicate.Replace<Products>(query.ElementType)));

    前面，我无法完成将TSource(Products)强制转换成匿名类型；但这里，通过构造Expression，来将类型弱化，最终将通过Expression的编译和执行功能，来实现这种转换。

    当然，每次这样写的话，我也觉得麻烦；于是，就有了下面的对IQueryable的扩展：

public static IQueryable DynamicWhere<T>(this IQueryable query, Expression<Func<T, bool>> predicate)

{

    if (predicate == null)

        return query;

    return query.Provider.CreateQuery(

        Expression.Call(

            typeof(Queryable), "Where",

            new Type[] { query.ElementType },

            query.Expression, predicate.Replace<T>(query.ElementType)));

}

//然后就可以这样用了：

public List<ProductExt> TestDynamicQuery3()

{

    using (NorthWindDataContext context = new NorthWindDataContext())

    {

        IQueryable query = from P in context.Products

                           join S in context.Suppliers

                            on P.SupplierID equals S.SupplierID

                           select new

                           {

                               P.ProductName,

                               P.UnitPrice,

                               P.QuantityPerUnit,

                               S.CompanyName,

                               S.Address

                           };

        query = query.DynamicWhere((Products p) => p.ProductName.Contains("che"))

            .DynamicWhere((Suppliers s) => s.Address == "P.O. Box 78934") 

            //.DynamicWhere((ProductExt p) => p.CompanyName == p.ProductName) //BinaryExpression右边不能有对参数的引用

            .DynamicWhere((Products p) => p.UnitPrice >= 5 * 4 + 2);

        return query.ConvertTo<ProductExt>();

    }

}

    由于Where<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate)已经被可耻地占去了，所以这里我定义了一个自己的方法名：DynamicWhere。

                                      ------------------又可耻了一次的分割线(happyhippy.cnblogs.com)--------------------

    最后，来说说这种方法的不足之处：
    (1). 由于我们在Expression<Func<TSource, bool>> predicate时，使用的源类型TSource与query中元素类型(匿名类型)之间的属性集可能存在不同，因此这里的Expression中，只能使用匿名类型中已经声明的属性，使用不属于该匿名类型的属性时，编译时不会抱错，但运行时会出错。例如，我还补充传入了一个根据供应商所在城市的过滤条件：.DynamicWhere((Suppliers s) => s.City== "London")，运行时就挂了……这就又遇到上一节中同样的问题：UI层怎么知道属性可用，哪些属性被阉割了呢？这又是一个问题，暂时只能说：源代码前没有秘密。
    (2). BinaryExpression中的右侧表达式不能包括对参数的应用。譬如上面代码中注释掉的一行，引用了参数p，执行会报错；这是因为在处理类型参数转换时，我对BinaryExpressio中的右侧表达式和CallExpression中的参数表达式进行了运算，转得到常量表达式。应该还有更好的思路，判断这些Expresion是否引用了参数，如果引用了参数，则不进行运算，如果没有引用参数，则进行运算。但是我还没有考虑出来该怎么来判断……于是就成了这个样子。不过对于动态查询来说，一般情况下应该够用了，以后想到更好的思路再加进去。

 

5. 如何进行逻辑复用

    为了将思路描述清楚，前面我只介绍了如何进行动态查询，而刻意避开了一个问题，就是如何进行逻辑复用。问题要分解开来，然后再逐个击破~

5.1 UI与业务逻辑层位于同一地址空间(同一个应用程序域)

    既然位于同一地址空间，那就可以在UI层创建Expression<Func<TSource, bool>> predicate，然后传入业务逻辑层：

public List<ProductExt> TestDynamicQuery(Expression<Func<ProductExt, bool>> predicate)

{

    using (NorthWindDataContext context = new NorthWindDataContext())

    {

        IQueryable query = from P in context.Products

                           join S in context.Suppliers

                            on P.SupplierID equals S.SupplierID

                           select new

                           {

                               P.ProductName,

                               P.UnitPrice,

                               P.QuantityPerUnit,

                               S.CompanyName

                           };

        return query.DynamicWhere(predicate).ConvertTo<ProductExt>();

    }

}

//不同场景下的应用：

//场景1

Expression<Func<ProductExt, bool>> predicate = t => t.ProductName.Contains("che") && t.UnitPrice >= 22;

return TestDynamicQuery2(predicate);

//场景2

Expression<Func<ProductExt, bool>> predicate = t => t.CompanyName == "New Orleans Cajun Delights";

return TestDynamicQuery2(predicate);

     但是这样又引入了新的问题，如何根据用户的输入条件，动态构造这个呢？ t => t.ProductName.Contains("che") && t.UnitPrice >= 22;

    虽然可以像下面5.2一样来处理，但是也还是有点儿麻烦；理想情况下，我希望可以像下面这样来构造predicate，这样，我们就可以使用&、| 、&=、|=来任意拼接过滤条件了：

   1: Expression<Func<ProductExt, bool>> predicate = null;

   2: predicate &= (t => t.ProductName.Contains("che")) | (t => t.UnitPrice >= 22);

 

5.2 UI与业务逻辑层位于不同地址空间(跨应用程序域)

    如果UI与业务逻辑位于不同的地址空间，Expression<Func<TSource, bool>> predicate就没有办法跨进程传递。

    一个可选办法是，将各个查询条件值作为参数(如果参数较多的话，或者经常变化的话，可以引入参数对象，具体可参考《重构》)，传到业务逻辑然后再构造Expression。如果您有好的思路，欢迎一起交流。

   1: NorthWindDataContext context = new NorthWindDataContext();

   2:  

   3: public List<ProductExt> TestDynamicQuery(string productName, decimal? unitPrice)

   4: {

   5:     IQueryable query = TestDynamicQueryAll(); //开放了IQueryable，延迟加载

   6:     if (!string.IsNullOrEmpty(productName))

   7:         query = query.DynamicWhere((ProductExt p) => p.ProductName.Contains(productName));

   8:     if (unitPrice.HasValue)

   9:         query = query.DynamicWhere<ProductExt>(p => p.UnitPrice >= unitPrice);

  10:  

  11:     return query.ConvertTo<ProductExt>();

  12: }

  13:  

  14: protected IQueryable TestDynamicQueryAll()

  15: {

  16:     IQueryable query = from P in context.Products

  17:                        join S in context.Suppliers

  18:                         on P.SupplierID equals S.SupplierID

  19:                        select new   //匿名类型

  20:                        {

  21:                            P.ProductName,

  22:                            P.UnitPrice,

  23:                            P.QuantityPerUnit,

  24:                            S.CompanyName

  25:                        };

  26:     return query;  //延迟加载

  27: }

    如果允许IQueryable满天飞的话，就没有5.1中提到的动态构造Expression的麻烦问题了。但是貌似看起来还是有点儿烦，能不能了个继续偷懒呢？

 

6. 上代码

    对IQueryable的DynamicWhere扩展，及对Expression<Func<TSource, bool>>的Replace扩展：Linq2SqlExtension.rar