动态 Linq 查询包含列表

本文关键字：列表 包含 查询 Linq 动态 | 更新日期: 2023-09-27 17:57:03

我正在使用动态Linq进行通用搜索。我有 ID 列表：

List<int> idList = new List<int> { 1, 5, 6};

用简单的Linq来说，我会写：

q = q.Where(a => idList.Contains(a.MyId));

但是现在我必须使用System.Linq.Dynamic，因为我事先不知道列的名称。

string someId = "CustomId";
q = q.Where("@0"+ ".Contains(" + someId + ")", idList.ToArray());

但这会产生错误：

"类型'Int32'中不存在适用的方法'包含'"

我怎样才能做到这一点？

是否有一些扩展库可以实现dynamic Linq 或其他方式的Contains。

动态 Linq 查询包含列表

你可以写这样的东西来动态构建你的查询函数：

public static Func<ObjT, bool> PropertyCheck<ObjT, PropT>(string propertyName, Expression<Func<PropT, bool>> predicate)
{
    var paramExpr = Expression.Parameter(typeof(ObjT));
    var propExpr = Expression.Property(paramExpr, propertyName);
    return Expression.Lambda<Func<ObjT, bool>>(Expression.Invoke(predicate, propExpr), paramExpr).Compile();
}

然后，它可以像这样使用：

foos.Where(PropertyCheck<Foo, int>("MyId", x => idList.Contains(x)));

当然，您也可以只提供自己的Where扩展方法，一次完成所有这些操作：

public static IEnumerable<T> Where<T, PropT>(this IEnumerable<T> self, string propertyName, Expression<Func<PropT, bool>> predicate)
{
    var paramExpr = Expression.Parameter(typeof(T));
    var propExpr = Expression.Property(paramExpr, propertyName);
    return self.Where<T>(Expression.Lambda<Func<T, bool>>(Expression.Invoke(predicate, propExpr), paramExpr).Compile());
}

foos.Where<Foo, int>("MyId", x => idList.Contains(x));
您可以使用

expressions来执行此动态查询，请尝试如下操作，例如：

导入这些命名空间：

using System.Linq;
using System.Linq.Expressions;
using System.Reflection;

试试这个：

// a reference parameter
var x = Expression.Parameter(typeof (YourType), "x");
// contains method
var containsMethod = typeof (string).GetMethod("Contains", new[] {typeof (string)});
// reference a field
var fieldExpression = Expression.Property(instance, "PropertyName");
// your value
var valueExpression = Expression.Constant(yourId);
// call the contains from a property and apply the value
var containsValueExpression = Expression.Call(fieldExpression, containsMethod, valueExpression);
// create your final lambda Expression
var filterLambda = Expression.Lambda<Func<YourType, bool>>(containsValueExpression, x);
// apply on your query
q = q.Where(finalLambda);

Obs：确保您的属性有一个名为 contains 的方法。

如果您查看动态 LINQ 的源代码，您会发现在许多情况下解析取决于变量predefinedTypes。

在您的情况下，您需要像这样更改此变量

static readonly Type[] predefinedTypes = {
    ....
    ,typeof(List<int>)
};

之后下一个代码将工作

List<int> idList = new List<int> { 1, 5, 6};
....
string someId = "CustomId";
q = q.Where("@0.Contains(" + someId + ")", idList);

@Felipe Oriani在他的90%答案中使用了string.Contains方法和yourId的单一值，但问题是：

q = q.Where(a => idList.Contains(a.MyId));

这是会员（财产）对a的访问。

所以这是最终测试的扩展方法：

/// <summary>
/// Creates lambda expression predicate: (TEntity entity) => collection.Contains(entity.property)
/// </summary>
public static Expression<Func<TEntity, bool>> ContainsExpression<TEntity, TProperty, TCollection>(
    this TCollection collection, 
    Expression<Func<TEntity, TProperty>> property
)
    where TCollection : ICollection<TProperty>
{
    // contains method
    MethodInfo containsMethod = typeof(TCollection).GetMethod(nameof(collection.Contains), new[] { typeof(TProperty) });
    // your value
    ConstantExpression collectionInstanceExpression = Expression.Constant(collection);
    // call the contains from a property and apply the value
    var containsValueExpression = Expression.Call(collectionInstanceExpression, containsMethod, property.Body);
    // create your final lambda Expression
    Expression<Func<TEntity, bool>> result = Expression.Lambda<Func<TEntity, bool>>(containsValueExpression, property.Parameters[0]);
    return result;
}

示例：

List<int> idList = new List<int> { 1, 5, 6 };
Expression<Func<MyEntity,int>> idExpression = entity => entity.Id;
var contains = idList.ContainsExpression(idExpression)
IQueryable<MyEntity> q = DbContext.Set<MyEntity>().Where(contains);

另一种给这只猫蒙皮的方法是将包含转换为 OR。

someArray.Constains（someField） 相当于：

someField == someArray[

0] 或 someField == someArray[1] 等等。

这并不理想，但如果阵列很小，它可以工作。

相关文章：