C# LINQ用户输入列WHERE子句

是否有任何方法可以根据查询中的用户输入动态更改

WHERE

子句

用户将选择要过滤的列以及该列中要过滤的id或内容

这是到目前为止我的代码

 public List<AssetDetailsToDisplay> FilterGridview2(String Samplequery)
    {
        try
        {
            using (Data.AMSEntities model = new Data.AMSEntities())
            {
                var list = from asset in model.Assets
                           join employee in model.Employees on asset.owner_id equals employee.employee_id into assetlist
                           where(Samplequery) // this is where the user inputed query should be executed

                           select new AssetDetailsToDisplay
                           {
                               id = asset.AssetSubClassRel.id,
                               asset_id = asset.asset_id,
                               short_description = asset.short_description,
                               inventory_id = asset.inventory_id,
                               class_id = asset.AssetClassRel.table_value,
                               subclass_id = asset.AssetSubClassRel.table_value,
                               ast_status_id = asset.AssetStatusRel.table_value,
                               location_id = asset.AssetLocationRel.table_value,
                               subclass_key = asset.AssetSubClassRel.table_key

                           };
                return list.ToList();
            }
        }
        catch (Exception ex)
        {
            throw ex;
        }
    }

像这样的

 var list = from asset in model.Assets
                       join employee in model.Employees on asset.owner_id equals employee.employee_id into assetlist
                       where asset.subclass_id == subclass_id 

---

是的，您可以这样做：

public class MyFilter 
{
   public int? ById { get; set; }
   public string ByName { get; set; }
   /// etc...
}

IQuerayble<Asset> GetAssets(MyFilter filter) 
{
    IQueryable<Asset> query = model.Assets; 
    if (filter.ById.HasValue)
        query = query.Where(a => a.Id == filter.ById.Value);
    if (!string.IsNullOrWhitespace(filter.ByName))
        query = query.Where(a => a.Id == filter.ByName);

    query = query.Select(... // your select code here);
    return query;
}

公共类MyFilter
{
公共int？ById{get；set；}
公共字符串ByName{get；set；}
///等等。。。
}
IQuerayble GetAssets（MyFilter筛选器）
{
IQueryable query=model.Assets；
if（filter.ById.HasValue）
query=query.Where（a=>a.Id==filter.ById.Value）；
如果（！string.IsNullOrWhitespace（filter.ByName））
query=query.Where（a=>a.Id==filter.ByName）；
query=query.Select（…//此处选择代码）；
返回查询；
}

---

如果只想传递列名和值，那么必须查看反射和C#

表达式

生成器。

是否尝试在任何字段中搜索

也许你应该试试这个IQueryable扩展。它可以搜索任何字符串属性

public static IQueryable<T> Relevant<T>(this IQueryable<T> qry, string keyword, bool AllKeywordMustExist = true, char keywordSeparator = ' ')
    {
        var parameter = Expression.Parameter(typeof(T), "relev");

        var objectType = typeof(T);
        var stringProperties = objectType.GetProperties().Where(m => m.PropertyType == typeof(string));

        var keywords = keyword.Split(keywordSeparator)
            .Where(m => !string.IsNullOrEmpty(m))
            .Select(m => m.ToLower())
            .Distinct();

        Expression completeExpression = Expression.Constant(AllKeywordMustExist);
        foreach (var keywordExpression in keywords.Select(m => Expression.Constant(m)))
        {
            Expression keywordCompleteExpression = Expression.Constant(false);
            foreach (var prop in stringProperties)
            {
                var containExpression = CreatePropertyContainExpression(parameter, prop, keywordExpression);
                var notNullExpression = Expression.NotEqual(Expression.PropertyOrField(parameter, prop.Name), Expression.Constant(null));
                var notNullContaintExpression = Expression.Condition(notNullExpression, containExpression, Expression.Constant(false));

                keywordCompleteExpression = Expression.Or(keywordCompleteExpression, notNullContaintExpression);
            }

            if (AllKeywordMustExist)
            {
                completeExpression = Expression.And(completeExpression, keywordCompleteExpression);
            }
            else
            {
                completeExpression = Expression.Or(completeExpression, keywordCompleteExpression);
            }
        }

        return qry.Where(Expression.Lambda<Func<T, bool>>(completeExpression, parameter));
    }

 private static Expression CreatePropertyContainExpression(Expression instance, PropertyInfo instanceProperty, Expression keyword)
    {
        var containMethod = typeof(string).GetMethods().FirstOrDefault(m => m.Name == "Contains" && m.GetParameters().Length == 1);
        var toLowerMethod = typeof(string).GetMethods().FirstOrDefault(m => m.Name == "ToLower" && m.GetParameters().Length == 0);

        var propParam = Expression.PropertyOrField(instance, instanceProperty.Name);
        var tolowerExp = Expression.Call(propParam, toLowerMethod);
        var containExpression = Expression.Call(tolowerExp, containMethod, keyword);

        return containExpression;
    }

---

这是一把小提琴，我想可能对你有帮助。看看这个

---

无论如何，我自己从来没有试过。

恐怕不行，用户可以自由选择要过滤的列。Ito lapid ftw！很高兴在这里看到菲律宾同胞，非常感谢！

public class MyFilter 
{
   public int? ById { get; set; }
   public string ByName { get; set; }
   /// etc...
}

IQuerayble<Asset> GetAssets(MyFilter filter) 
{
    IQueryable<Asset> query = model.Assets; 
    if (filter.ById.HasValue)
        query = query.Where(a => a.Id == filter.ById.Value);
    if (!string.IsNullOrWhitespace(filter.ByName))
        query = query.Where(a => a.Id == filter.ByName);

    query = query.Select(... // your select code here);
    return query;
}

public static IQueryable<T> Relevant<T>(this IQueryable<T> qry, string keyword, bool AllKeywordMustExist = true, char keywordSeparator = ' ')
    {
        var parameter = Expression.Parameter(typeof(T), "relev");

        var objectType = typeof(T);
        var stringProperties = objectType.GetProperties().Where(m => m.PropertyType == typeof(string));

        var keywords = keyword.Split(keywordSeparator)
            .Where(m => !string.IsNullOrEmpty(m))
            .Select(m => m.ToLower())
            .Distinct();

        Expression completeExpression = Expression.Constant(AllKeywordMustExist);
        foreach (var keywordExpression in keywords.Select(m => Expression.Constant(m)))
        {
            Expression keywordCompleteExpression = Expression.Constant(false);
            foreach (var prop in stringProperties)
            {
                var containExpression = CreatePropertyContainExpression(parameter, prop, keywordExpression);
                var notNullExpression = Expression.NotEqual(Expression.PropertyOrField(parameter, prop.Name), Expression.Constant(null));
                var notNullContaintExpression = Expression.Condition(notNullExpression, containExpression, Expression.Constant(false));

                keywordCompleteExpression = Expression.Or(keywordCompleteExpression, notNullContaintExpression);
            }

            if (AllKeywordMustExist)
            {
                completeExpression = Expression.And(completeExpression, keywordCompleteExpression);
            }
            else
            {
                completeExpression = Expression.Or(completeExpression, keywordCompleteExpression);
            }
        }

        return qry.Where(Expression.Lambda<Func<T, bool>>(completeExpression, parameter));
    }

 private static Expression CreatePropertyContainExpression(Expression instance, PropertyInfo instanceProperty, Expression keyword)
    {
        var containMethod = typeof(string).GetMethods().FirstOrDefault(m => m.Name == "Contains" && m.GetParameters().Length == 1);
        var toLowerMethod = typeof(string).GetMethods().FirstOrDefault(m => m.Name == "ToLower" && m.GetParameters().Length == 0);

        var propParam = Expression.PropertyOrField(instance, instanceProperty.Name);
        var tolowerExp = Expression.Call(propParam, toLowerMethod);
        var containExpression = Expression.Call(tolowerExp, containMethod, keyword);

        return containExpression;
    }

data.Relevant("rob");