Question

我为第三方api构建自己的IQuerable实现。

此Api接受过滤器作为OR的列表，其中包含AND语句和fitlers列表，如下所示：

public class Or {
    List<And> ands
}

public class And {
   field, operator, value..
}

Filters = new List<Or>();

现在构建这些过滤器很顺利，每当我有一个或语句我爆炸所有当前过滤器时或者每当我得到并声明我将其添加到所有或者。这些似乎工作得很好，除非现在每当我有一个一元不在多个领域的表达时，我迷路了。

说我有：(a and b) or (c and d) 这会变成过滤器：

 a, b  // list of ands, vertical list of or
 c, d

否定这将导致：(!a or !b) and (!c or !d)

!a, !c
!a, !d
!b, !c
!b, !d

这仍然是可能的，但我想弄清楚的是，如果它会被双重否定，我将如何能够还原它，这将再次导致(a and b) or (c and d)。但我似乎无法弄明白。也许我应该使用不同的中间过滤器结构，然后将它们转换为这些和/或列表。我怎么能做到这一点？

Answer 1

当您反转示例时，它会变成一个更大的列表，正如您所指出的那样：

!((a & b) | (c & d))
!(a & b) & !(c & d)                           // De Morgan's laws
(!a | !b) & (!c | !d)                         // De Morgan's laws
(!a & !c) | (!a & !d) | (!b & !c) | (!b & !d) // Normalization

再次反转时，列表会变得更大：

!((!a & !c) | (!a & !d) | (!b & !c) | (!b & !d))
!(!a & !c) & !(!a & !d) & !(!b & !c) & !(!b & !d)     // De Morgan's laws
(!!a | !!c) & (!!a | !!d) & (!!b | !!c) & (!!b | !!d) // De Morgan's laws
(a | c) & (a | d) & (b | c) & (b | d)                 // Double negation
(a & a & b & b) | (a & a & b & d) | (a & a & c & b) | (a & a & c & d) | (a & d & b & b) | (a & d & b & d) | (a & d & c & b) | (a & d & c & d) | (c & a & b & b) | (c & a & b & d) | (c & a & c & b) | (c & a & c & d) | (c & d & b & b) | (c & d & b & d) | (c & d & c & b) | (c & d & c & d) // Normalization

哇，最后一行确定很长！您已经注意到一些联合条款有重复，即a & a & b & b。因此，第一步是删除重复的谓词：

(a & b) | (a & b & d) | (a & c & b) | (a & c & d) | (a & d & b) | (a & d & b) | (a & d & c & b) | (a & d & c) | (c & a & b) | (c & a & b & d) | (c & a & b) | (c & a & d) | (c & d & b) | (c & d & b) | (c & d & b) | (c & d)

现在我们可以在每个连词中排序谓词，并删除重复的连词：

(a & b) | (a & b & c) | (a & b & c & d) | (a & b & d) | (a & c & d) | (b & c & d) | (c & d)

好的，这清理了很多！但是，我们在这个表达方面仍然比我们开始时有更多。如果仔细观察，其中一些连词是多余的 - 例如a & b & c => a & b。所以，如果一个连词是另一个连词的超集，我们可以删除它：

(a & b) | (c & d)

原条款！由于您没有在问题中包含任何代码，因此我不会在答案中包含任何代码 - 执行上述步骤取决于您。但是，我建议您简化模型：

public class Predicate
{
    public string Field { get; set; }
    public Operator Operator { get; set; }
    public string Value { get; set; }
}

public enum NormalForm
{
    Conjunctive,
    Disjunctive
}

public class Filter
{
    public NormalForm NormalForm { get; set; }
    public List<List<Predicate>> Predicates { get; set; }
}

这是一种更灵活的表示方式，并且会使反转变得更容易，因为在您应用了De Morgan定律之后，您最终会得到联合正规形式并且必须转换回来。

C＃表达式访问者，如何否定构建过滤器

1 个答案: