LINQ模糊查询学习体验浅析

LINQ模糊查询来实现复合搜索的功能，具体的操作过程是什么呢？在这里向你介绍一下处理过程，使用LINQ模糊查询有什么需要注意的呢？那么我们通过这个例子希望对你有所启发。

创新互联公司专注为客户提供全方位的互联网综合服务，包含不限于网站制作、做网站、中站网络推广、小程序开发、中站网络营销、中站企业策划、中站品牌公关、搜索引擎seo、人物专访、企业宣传片、企业代运营等，从售前售中售后，我们都将竭诚为您服务，您的肯定，是我们最大的嘉奖；创新互联公司为所有大学生创业者提供中站建站搭建服务，24小时服务热线：13518219792，官方网址：www.cdcxhl.com

LINQ模糊查询实现的多条件复合搜索效果如下图：

LINQ模糊查询实现阶段一：

首先是找到了李永京（YJingLee）前辈的《LINQ体验(17)——LINQ to SQL语句之动态查询》一文，利用Lambda表达式树可以进行动态查询。写了个方法进行复合查询，动态组合条件，生成Lambda表达式。

 
 
 
 
    
  
  
  
  
  1. ///  
    2. 
  
  
  
  
  2. /// 这个方法带分页功能，通过输入的键值对NVC进行复合查询 
    3. 
  
  
  
  
  3. ///  
    4. 
  
  
  
  
  4. List GetPagedObjectsByNVC( 
    5. 
  
  
  
  
  5. int startIndex, int pageSize,  
    6. 
  
  
  
  
  6. NameValueCollection nvc, bool isAnd) 
    7. 
  
  
  
  
  7. { 
    8. 
  
  
  
  
  8. IQueryable query =  
    9. 
  
  
  
  
  9. Consulting.Instance.UserT_TractInfo; 
    10. 
  
  
  
  
  10. query.Where(t => t.IsDel == 0). 
    11. 
  
  
  
  
  11. Where(t => t.IsAuditing == 1);//审核和逻辑删除 
    12. 
  
  
  
  
  12. 
  
  
  
  
  13. Expression condition = null; 
    14. 
  
  
  
  
  14. ParameterExpression param = Expression. 
    15. 
  
  
  
  
  15. Parameter(typeof(UserT_TractInfo), "c"); 
    16. 
  
  
  
  
  16. int propertyCount = 0; 
    17. 
  
  
  
  
  17. foreach (string key in nvc) 
    18. 
  
  
  
  
  18. { 
    19. 
  
  
  
  
  19. Expression right = Expression.Constant(nvc[key]);//键 
    20. 
  
  
  
  
  20. string keyProperty = key;//属性 
    21. 
  
  
  
  
  21. if (typeof(UserT_TractInfo).GetProperty(keyProperty) != null) 
    22. 
  
  
  
  
  22. //当对象存在此属性时（因为键值对可能还有很多其他的参数，例如page） 
    23. 
  
  
  
  
  23. { 
    24. 
  
  
  
  
  24.   Expression left = Expression.Property(param, 
    25. 
  
  
  
  
  25. typeof(UserT_TractInfo).GetProperty(keyProperty));//建立属性 
    26. 
  
  
  
  
  26.   Expression filter = Expression.Equal(left, right);//过滤器 
    27. 
  
  
  
  
  27.   if (condition == null) 
    28. 
  
  
  
  
  28.   { 
    29. 
  
  
  
  
  29. condition = filter; 
    30. 
  
  
  
  
  30.   } 
    31. 
  
  
  
  
  31.   else
    32. 
  
  
  
  
  32.   { 
    33. 
  
  
  
  
  33.  if (isAnd) 
    34. 
  
  
  
  
  34.  { 
    35. 
  
  
  
  
  35. condition = Expression.And(condition, filter); 
    36. 
  
  
  
  
  36.  } 
    37. 
  
  
  
  
  37.  else
    38. 
  
  
  
  
  38.  { 
    39. 
  
  
  
  
  39. condition = Expression.Or(condition, filter); 
    40. 
  
  
  
  
  40.  } 
    41. 
  
  
  
  
  41.   } 
    42. 
  
  
  
  
  42.   propertyCount++; 
    43. 
  
  
  
  
  43. } 
    44. 
  
  
  
  
  44. } 
    45. 
  
  
  
  
  45. //以上foreach组合了各个有效的键值对对应的conditionExpression， 
    46. 
  
  
  
  
  46. //复合查询最重要的组合工作就这么完了 
    47. 
  
  
  
  
  47. if (propertyCount > 0) 
    48. 
  
  
  
  
  48. { 
    49. 
  
  
  
  
  49. Expression pred = Expression.Lambda(condition, param); 
    50. 
  
  
  
  
  50. MethodCallExpression whereCallExpression =  
    51. 
  
  
  
  
  51. Expression.Call(typeof(Queryable), "Where",  
    52. 
  
  
  
  
  52. new Type[] { typeof(UserT_TractInfo) }, 
    53. 
  
  
  
  
  53.  Expression.Constant(query), pred); 
    54. 
  
  
  
  
  54. 
  
  
  
  
  55. return Consulting.Instance.UserT_TractInfo.AsQueryable(). 
    56. 
  
  
  
  
  56. Provider.CreateQuery(whereCallExpression). 
    57. 
  
  
  
  
  57. OrderByDescending(t => t.ID).Skip(startIndex - 1). 
    58. 
  
  
  
  
  58. Take(pageSize).ToList();//查询出结果 
    59. 
  
  
  
  
  59. } 
    60. 
  
  
  
  
  60. else
    61. 
  
  
  
  
  61. { 
    62. 
  
  
  
  
  62. return Consulting.Instance.UserT_TractInfo. 
    63. 
  
  
  
  
  63. OrderByDescending(t => t.ID).Skip(startIndex - 1). 
    64. 
  
  
  
  
  64. Take(pageSize).ToList(); 
    65. 
  
  
  
  
  65. //如果没有有效键值对，则返回全部结果 
    66. 
  
  
  
  
  66. } 
    67. 
  
  
  
  
  67. } 
    68.

搞了半天本来很兴奋的，之后才知道Lambda表达式是写不出.Contains()的，我的心瓦凉瓦凉的。

LINQ模糊查询实现阶段二：

虽然李永京的文章没给我多少帮助，但它后面有个回复很有价值：“用微软提供的System.Linq.Dynamic方便点。”很快找到了对应例子和Dynamic.cs，也找到了《Linq to SQL Dynamic 动态查询》，有更细致的例子，可惜Dynamic.cs也是不能使用like的，恨啊！

 
 
 
 
    
  
  
  
  
  1. return Consulting.Instance.UserT_TractInfo.Where( 
    2. 
  
  
  
  
  2. "b_number == @0","P(2007)031").OrderByDescending(t => t.ID). 
    3. 
  
  
  
  
  3. Skip(startIndex - 1).Take(pageSize).ToList();
    4.

代码很容易，但没什么用：（

LINQ模糊查询实现阶段三：

中文的实在是找不到了，在MS的官方BBS上找到了个链接，非常有用！《dynamic linq queries / dynamic where clause (part 2) 》，这个老外扩展了Dynamic.cs，写了个PredicateExtensions类，虽然不知道他是怎么想出来的，但确实有效！

这里放出核心代码，很容易看懂，简单就是美！

 
 
 
 
    
  
  
  
  
  1. searchPredicate = PredicateExtensions. 
    2. 
  
  
  
  
  2. True(); 
    3. 
  
  
  
  
  3. foreach (string key in nvcParam) 
    4. 
  
  
  
  
  4. { 
    5. 
  
  
  
  
  5. string condition = string.Empty; 
    6. 
  
  
  
  
  6. switch (key) 
    7. 
  
  
  
  
  7. { 
    8. 
  
  
  
  
  8.   case "b_number": 
    9. 
  
  
  
  
  9.  condition = nvcParam[key]; 
    10. 
  
  
  
  
  10.  searchPredicate = searchPredicate.And(u => 
    11. 
  
  
  
  
  11.  u.B_number.Contains(condition)); 
    12. 
  
  
  
  
  12.  break; 
    13. 
  
  
  
  
  13.   case "b_address": 
    14. 
  
  
  
  
  14.  condition = nvcParam[key]; 
    15. 
  
  
  
  
  15.  searchPredicate = searchPredicate.And(u =>  
    16. 
  
  
  
  
  16. u.B_address.Contains(condition)); 
    17. 
  
  
  
  
  17.  break; 
    18. 
  
  
  
  
  18.   case "b_canton": 
    19. 
  
  
  
  
  19.  condition = nvcParam[key]; 
    20. 
  
  
  
  
  20.  searchPredicate = searchPredicate.And(u =>  
    21. 
  
  
  
  
  21. u.B_canton.Contains(condition)); 
    22. 
  
  
  
  
  22.  break; 
    23. 
  
  
  
  
  23.   case "a_status": 
    24. 
  
  
  
  
  24.  condition = nvcParam[key]; 
    25. 
  
  
  
  
  25.  searchPredicate = searchPredicate.And(u =>  
    26. 
  
  
  
  
  26. u.A_status.ToString().Contains(condition)); 
    27. 
  
  
  
  
  27.  break; 
    28. 
  
  
  
  
  28.   case "b_area": 
    29. 
  
  
  
  
  29.  condition = nvcParam[key]; 
    30. 
  
  
  
  
  30.  searchPredicate = searchPredicate.And(u => 
    31. 
  
  
  
  
  31.  u.B_area.Contains(condition)); 
    32. 
  
  
  
  
  32.  break; 
    33. 
  
  
  
  
  33.   case "c_clinchdate": 
    34. 
  
  
  
  
  34.  condition = nvcParam[key]; 
    35. 
  
  
  
  
  35.  searchPredicate = searchPredicate.And(u =>  
    36. 
  
  
  
  
  36. u.C_clinchdate.Contains(condition)); 
    37. 
  
  
  
  
  37.  break; 
    38. 
  
  
  
  
  38.   default: 
    39. 
  
  
  
  
  39.  break; 
    40. 
  
  
  
  
  40. } 
    41. 
  
  
  
  
  41. } 
    42. 
  
  
  
  
  42. 
  
  
  
  
  43. return Consulting.Instance.UserT_TractInfo. 
    44. 
  
  
  
  
  44. Where(searchPredicate).OrderByDescending(t => t.ID). 
    45. 
  
  
  
  
  45. Skip(startIndex - 1).Take(pageSize).ToList(); 
    46.

下面是我写了注释后的PredicateExtensions，我说不清楚构造函数的True和False具体是怎么起作用的，但结果就是我的注释那样，在复合查询写条件时很重要（不过目前全写AND就完成复合查询了，我还没搞多关键词OR的那种）：

 
 
 
 
    
  
  
  
  
  1. ///  
    2. 
  
  
  
  
  2. /// 构造函数使用True时：单个AND有效，多个AND有效； 
    3. 
  
  
  
  
  3. ///单个OR无效，多个OR无效；混合时写在AND后的OR有效 
    4. 
  
  
  
  
  4. /// 构造函数使用False时：单个AND无效，多个AND无效； 
    5. 
  
  
  
  
  5. ///单个OR有效，多个OR有效；混合时写在OR后面的AND有效 
    6. 
  
  
  
  
  6. ///  
    7. 
  
  
  
  
  7. public static class PredicateExtensions 
    8. 
  
  
  
  
  8. { 
    9. 
  
  
  
  
  9. public static Expression
  
  
  
  
  10. bool>> True() { return f => true; } 
    11. 
  
  
  
  
  11. 
  
  
  
  
  12. public static Expression> False() {  
    13. 
  
  
  
  
  13. return f => false; } 
    14. 
  
  
  
  
  14. public static Expression> 
    15. 
  
  
  
  
  15.  Or(this Expression> expression1,  
    16. 
  
  
  
  
  16. Expression> expression2) 
    17. 
  
  
  
  
  17. { 
    18. 
  
  
  
  
  18. var invokedExpression = Expression.Invoke( 
    19. 
  
  
  
  
  19. expression2, expression1.Parameters.Cast()); 
    20. 
  
  
  
  
  20. 
  
  
  
  
  21. return Expression.Lambda>( 
    22. 
  
  
  
  
  22. Expression.Or(expression1.Body,  
    23. 
  
  
  
  
  23. invokedExpression),  
    24. 
  
  
  
  
  24. expression1.Parameters); 
    25. 
  
  
  
  
  25. } 
    26. 
  
  
  
  
  26. 
  
  
  
  
  27. public static Expression> And( 
    28. 
  
  
  
  
  28. this Expression> expression1,  
    29. 
  
  
  
  
  29. Expression> expression2) 
    30. 
  
  
  
  
  30. { 
    31. 
  
  
  
  
  31. var invokedExpression =  
    32. 
  
  
  
  
  32. Expression.Invoke(expression2,  
    33. 
  
  
  
  
  33. expression1.Parameters.Cast()); 
    34. 
  
  
  
  
  34. 
  
  
  
  
  35. return Expression.Lambda> 
    36. 
  
  
  
  
  36. (Expression.And(expression1.Body, invokedExpression), 
    37. 
  
  
  
  
  37.  expression1.Parameters); 
    38. 
  
  
  
  
  38. } 
    39. 
  
  
  
  
  39. } 
    40.

原文来自：http://www.cnblogs.com/killuakun/archive/2008/08/03/1259389.html

LINQ模糊查询实现复合搜索的基本内容就向你介绍到这里，希望对你了解和掌握复合搜索的LINQ模糊查询实现有所帮助。

当前题目：LINQ模糊查询学习体验浅析
URL网址：http://www.36103.cn/qtweb/news29/27029.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

网站维护知识

同城分类信息

亮美家　　 　成都商城网站建设　　 　成都IDC机房托管　　 　犀浦雨棚定制　　 　成都木托盘　　 　成都木托盘　　 　重庆网站建设　　 　青年旅行社　　 　四川航空文化　　 　雅安服务器托管　　 　商城网站　　 　手机app　　 　画册设计制作　　 　营销推广　　 　成都LED显示屏　　 　中晴建设　　 　成都网站建设　　 　成都网页设计　　 　成都网站建设　　 　成都封阳台