如何根据输入参数条件动态创建“OR”LINQ查询

mtb9vblg  于 2024-01-03  发布在  其他
关注(0)|答案(2)|浏览(191)

我的问题有点复杂，所以我用下面的例子简化了它。
假设我有一个简单的整数列表。我在函数中接收两个条件输入参数，它们告诉我如何过滤。类似这样：

  1. public class input{
  2.        public string operation = "less than";//can be <=, >=, !=, ==,<. >, etc. 
  3.        public integer filter = 9;
  4. }

字符串
我想根据传入的条件进行动态过滤，但我需要将其作为“OR”子句。
如何动态地创建一个linq查询，而不像这样对每个组合进行硬编码：

  1. /*
  2. input one = { operation = "less than" , filter = 9 }
  3. input two = { operation = "equal to", filter =10 }
  4. arraytoFilter { 1,2,3,4,5,6,7,8,9,10,11,12 }
  5. */
  6. public int[] myFilter(input one, input two, int[] arraytoFilter){
  8.  if (one.operation == "less than" && two.operation == "equal to"){
  10.     return arraytoFilter.Where(x => x < one.filter || x == two.filter)
  12.    }
  14.     if (one.operation == "less than or equal to" && two.operation == "greater than"){
  16.     return arraytoFilter.Where(x => x <= one.filter || x > two.filter)
  18.    }
  19.  /// rest of all combinations (how do I avoid doing this???)
  20.     return arrayToFilter;
  21. }

型

linq

2条答案

按热度按时间
2exbekwf

2exbekwf1#

[更新11/20 ]
这可以在没有NuGet包的情况下通过使用System.Linq.Expressions构建表达式来完成：

  1. using System.Linq.Expressions;
  3. class Program
  4. {
  5.     public class input
  6.     {
  7.         public string? operation { get; set; }
  8.         public int filter { get; set; }
  9.     }
  11.     static void Main()
  12.     {
  13.         int[] arrayToFilter = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };
  15.         input one = new()
  16.         {
  17.             operation = "less than",
  18.             filter = 9
  19.         };
  21.         input two = new()
  22.         {
  23.             operation = "equal to",
  24.             filter = 10
  25.         };
  27.         var filteredArray = myFilter(one, two, arrayToFilter);
  29.         foreach (var number in filteredArray)
  30.         {
  31.             Console.WriteLine(number);
  32.         }
  33.     }
  35.     static int[] myFilter(input one, input two, int[] arrayToFilter)
  36.     {
  37.         var parameter = Expression.Parameter(typeof(int), "num");
  38.         var firstComparisonExpression = GetComparisonExpression(parameter, one.operation, one.filter);
  39.         var secondComparisonExpression = GetComparisonExpression(parameter, two.operation, two.filter);
  41.         // Short-circuiting OR
  42.         var orElseExpression = Expression.OrElse(firstComparisonExpression, secondComparisonExpression);
  44.         var lambda = Expression.Lambda<Func<int, bool>>(orElseExpression, parameter);
  45.         
  46.         return arrayToFilter.AsQueryable().Where(lambda.Compile()).ToArray();
  47.     }
  49.     static Expression GetComparisonExpression(ParameterExpression parameter, string? operation, int filter)
  50.     {
  51.         switch (operation)
  52.         {
  53.             case "less than":
  54.                 return Expression.LessThan(parameter, Expression.Constant(filter));
  55.             case "less than or equal to":
  56.                 return Expression.LessThanOrEqual(parameter, Expression.Constant(filter));
  57.             case "greater than":
  58.                 return Expression.GreaterThan(parameter, Expression.Constant(filter));
  59.             case "greater than or equal to":
  60.                 return Expression.GreaterThanOrEqual(parameter, Expression.Constant(filter));
  61.             case "equal to":
  62.                 return Expression.Equal(parameter, Expression.Constant(filter));
  63.             case "not equal to":
  64.                 return Expression.NotEqual(parameter, Expression.Constant(filter));
  65.             default:
  66.                 throw new ArgumentException("Invalid operation phrase.");
  67.         }
  68.     }
  69. }

字符串
您可以使用System.Linq.Dynamic.Core包来编写动态LINQ查询。下面的程序已在1.3.5版本中测试：

  1. using System.Linq.Dynamic.Core;
  3. class Program
  4. {
  5.     public class input
  6.     {
  7.         public string? operation { get; set; }
  8.         public int filter { get; set; }
  9.     }
  11.     static void Main()
  12.     {
  13.         int[] arrayToFilter = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };
  15.         input one = new()
  16.         {
  17.             operation = "less than",
  18.             filter = 9
  19.         };
  21.         input two = new()
  22.         {
  23.             operation = "equal to",
  24.             filter = 10
  25.         };
  27.         var filteredArray = myFilter(one, two, arrayToFilter);
  29.         foreach (var number in filteredArray)
  30.         {
  31.             Console.WriteLine(number);
  32.         }
  33.     }
  35.     static int[] myFilter(input one, input two, int[] arrayToFilter)
  36.     {
  37.         var firstSymbol = ConvertOperationToSymbol(one.operation);
  38.         var secondSymbol = ConvertOperationToSymbol(two.operation);
  40.         string dynamicQuery = $"it {firstSymbol} {one.filter} || it {secondSymbol} {two.filter}";
  42.         return arrayToFilter.AsQueryable().Where(dynamicQuery).ToArray();
  43.     }
  45.     static string ConvertOperationToSymbol(string? operation)
  46.     {
  47.         switch (operation)
  48.         {
  49.             case "less than":
  50.                 return "<";
  51.             case "less than or equal to":
  52.                 return "<=";
  53.             case "greater than":
  54.                 return ">";
  55.             case "greater than or equal to":
  56.                 return ">=";
  57.             case "equal to":
  58.                 return "==";
  59.             case "not equal to":
  60.                 return "!=";
  61.             default:
  62.                 throw new ArgumentException("Invalid operation phrase.");
  63.         }
  64.     }
  65. }

型

展开查看全部
赞(0）分享  回复(0）举报  2024-01-03
u7up0aaq

u7up0aaq2#

您应该需要强大的 * System.Linq.Expressions * 来构造表达式树和过滤器。

  1. using System.Collections.Generic;
  2. using System.Linq;
  3. using System.Linq.Expressions;
  5. public static int[] BuildFilter(int[] source, params Input[] inputs)
  6. {
  7.     var param = Expression.Parameter(typeof(int), "x");
  9.     List<BinaryExpression> expressions = new List<BinaryExpression>();
  10.     BinaryExpression combineExpression = null;
  12.     if (inputs != null && inputs.Any())
  13.     {
  14.         foreach (Input input in inputs)
  15.         {
  16.             var constant = Expression.Constant(input.filter);
  18.             switch (input.operation)
  19.             {
  20.                 case "equal to":
  21.                     expressions.Add(Expression.Equal(param, constant));
  22.                     break;
  24.                 case "not equal":
  25.                     expressions.Add(Expression.NotEqual(param, constant));
  26.                     break;
  28.                 case "less than":
  29.                     expressions.Add(Expression.LessThan(param, constant));
  30.                     break;
  32.                 case "less than or equal to":
  33.                     expressions.Add(Expression.LessThanOrEqual(param, constant));
  34.                     break;
  36.                 case "greater than":
  37.                     expressions.Add(Expression.GreaterThan(param, constant));
  38.                     break;
  40.                 case "greater than or equal to":
  41.                     expressions.Add(Expression.GreaterThanOrEqual(param, constant));
  42.                     break;
  44.                 default:
  45.                     throw new Exception("Operation is not supported");
  46.             }           
  47.         }
  49.         combineExpression = expressions[0];
  51.         foreach (var expr in expressions.Skip(1))
  52.         {
  53.             combineExpression = Expression.OrElse(combineExpression, expr);
  54.         }
  55.     }
  57.     var lambda = combineExpression != null
  58.         ? Expression.Lambda<Func<int, bool>>(combineExpression, param)
  59.         : Expression.Lambda<Func<int, bool>>(Expression.Constant(true), param);
  61.     return source.Where(lambda.Compile())
  62.         .ToArray();
  63. }

字符串
呼叫方方法：

  1. Input[] input = new Input[]
  2. {
  3.     new Input { operation = "less than" , filter = 9 },
  4.     new Input { operation = "equal to", filter = 10 }
  5. };
  6. int[] arraytoFilter  = new int[] { 1,2,3,4,5,6,7,8,9,10,11,12 };
  8. var result = BuildFilter(arraytoFilter, input);

型

展开查看全部
赞(0）分享  回复(0）举报  2024-01-03
我来回答

相关问题

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新问答

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com