如何针对分层对象列表动态构建和存储复杂的 linq 查询？

Question

我有一个分层结构的对象列表。我想根据客户公司设置并存储在数据库中的“条件”针对该对象列表构建复杂的 LINQ 查询。所以我需要在运行时构建它们，但是因为每当客户端的用户更新或刷新他们的数据时它们都会重复运行，所以我想将 LINQ 查询存储在对象中，而不是每次都重新构建它们。

我看过 ScottGu 关于Dynamic LINQ 的博客。
还有这篇关于使用expression trees的文章。
这些似乎都没有提供足够的解决方案，但我可能没有充分理解它们。恐怕我应该考虑其他选项时尝试使用 LINQ。

我的对象层次结构：

WorkOrder[]
    Field[]
    Task[]
        Field[]

这是一个我想存储和执行的 LINQ 查询示例。我可以根据定义条件的数据库记录合理地构建这种格式。

var query =
from wo in WorkOrders
from woF in wo.Fields
from task in wo.Tasks
from taskF in task.Fields
from taskF2 in task.Fields
where woF.Name == "System Status"
    && woF.Value.Contains("SETC")
    && taskF.Name == "Material"
    && taskF.Value == "Y"
    && taskF2.Name == "Planner"
    && taskF2.Value == "GR5259"
select new
{
    wo_id = wo.ID,
    task_id = task.ID
};

一些注意事项。

• 根据用户定义条件的复杂性，我可能需要也可能不需要从不同的对象列表中提取：“froms”是动态的。
• 请注意，在此示例中，我从 task.fields[] 中提取了两次，因此我为它设置了两次别名。
• 示例 LINQ 结构允许我使用复杂的 AND、OR、括号等，我认为这些对于动态链接或表达式树是不实用的。

在我的代码中我设想：

//1) Retrieve business rules from DB. I can do this.

//2) Iterate through the business rules to build the linq queries.
foreach (BusinessRule br in BusinessRules) {
    //Grab the criteria for the rule from the DB. 

    //Create a linq to object query based on the criteria just built.
    //Add this query to a list for later use.
}

...Elsewhere in application.

//Iterate through and execute the linq queries in order to apply business rules to data cached in the application.
foreach (LinqQuery q in LinqQueries) {
    //Execute the query

    //Apply business rule to the results.
}

非常感谢您的想法、努力和想法。

Answer 1

从技术上讲，您只需使用 LINQ 即可实现所需的功能，但 PredicateBuilder 是一个不错的实用程序类：

public enum AndOr
{
    And,
    Or
}

public enum QueryableObjects
{
    WorkOrderField,
    TaskField
}

public class ClientCondition
{
    public AndOr AndOr;
    public QueryableObjects QueryableObject;
    public string PropertyName;
    public string PropertyValue;
}

public void PredicateBuilderExample()
{
    var conditions = new List<ClientCondition> {
    {
        new ClientCondition { AndOr = LINQ.AndOr.And,
            QueryableObject = QueryableObjects.WorkOrderField,
            PropertyName = "System Status",
            PropertyValue = "SETC"
        }
    },
    {
        new ClientCondition{AndOr = AndOr.And,
            QueryableObject = QueryableObjects.TaskField,
            PropertyName = "Material",
            PropertyValue = "Y"
        }
    },
    {
        new ClientCondition{AndOr = AndOr.Or,
            QueryableObject = QueryableObjects.TaskField,
            PropertyName = "Planner",
            PropertyValue = "GR5259"
        }
    }
    };

    //Obviously this WorkOrder object is empty so it will always return empty lists when queried.
    //Populate this yourself.
    var WorkOrders = new List<WorkOrder>();

    var wofPredicateBuilder = PredicateBuilder.True<WorkOrderField>();
    var tfPredicateBuilder = PredicateBuilder.True<TaskField>();

    foreach (var condition in conditions)
    {
        if (condition.AndOr == AndOr.And)
        {
            if (condition.QueryableObject == QueryableObjects.WorkOrderField)
            {
                wofPredicateBuilder = wofPredicateBuilder.And(
                    wof => wof.Name == condition.PropertyName &&
                        wof.Value.Contains(condition.PropertyValue));
            }
        }
        if (condition.AndOr == AndOr.Or)
        {
            if (condition.QueryableObject == QueryableObjects.TaskField)
            {
                tfPredicateBuilder = tfPredicateBuilder.Or(
                    tf => tf.Name = condition.PropertyName &&
                        tf.Value.Contains(condition.PropertyValue));
            }
        }
        //And so on for each condition type.
    }

    var query = from wo in WorkOrders
                from woF in wo.Fields.AsQueryable().Where(wofPredicateBuilder)
                from task in wo.Tasks
                from taskF in task.Fields.AsQueryable().Where(tfPredicateBuilder)
                select new
                {
                    wo_id = wo.ID,
                    task_id = task.ID
                };
}

请注意，我使用枚举来限制您的客户可以发送给您的可能条件。要拥有一个真正动态的可查询引擎，您需要使用反射来确保您收到的对象名称是有效的。这似乎是一个相当大的范围，此时我建议研究一种不同的方法，例如ElasticSearch。

还要注意 And 和 Ors 的顺序很重要。从本质上讲，您允许您的客户针对您的数据构建 SQL 查询，而这通常以泪水告终。将它们限制在它们应该查询的适当条件集是您的工作。

Answer 2

根据与 Guillaume 的讨论，我只建议在使用高级动态查询生成时注意结果查询的类型。如果您正在更改通过Select、Aggregate 或其他方法之一返回的内容的形状，您会期望您的内部类型会相应更改。如果您只是使用 Where 进行过滤，除非您想要 OR 行为，否则您可以继续添加尽可能多的其他案例，那么 PredicateBuilder 之类的东西会有所帮助。如果您想通过Join、Zip、...获取更多数据，那么您要么进行过滤，要么添加到返回的行，并可能更改数据的形状。

我过去做过很多这样的工作，并且最成功的是专注于特定的帮助方法，这些方法允许我需要的常见情况，然后依靠 linq 表达式树和模式（例如访问者模式）来允许构建自定义表达式在运行时。