C# 表达式比较

Question

假设我在一个集合上有以下表达式：

var people = new List<Person>
{
     new Person {FullName = "Some Dude", Age = 45},
     new Person {FullName = "Another Dude", Age = 28},
     new Person {FullName = "Some Other Dude", Age = 36}
 };

var filtered = people.Where(person => person.Age > 28 && person.FullName.StartsWith("So"));
var narrowlyFiltered = people.Where(person => person.Age > 36 && person.FullName.StartsWith("Some"));

有没有办法比较这两个表达式并推断出第二个表达式是运行时第一个表达式的子集？无需枚举或其他任何内容。我只有表达式，我试图找出这些表达式是否相交或包含彼此。

Answer 1

如果您可以枚举您的集合，您可以先将元素放入HashSet<T>，然后在其上运行HashSet<T>.IsSubSet：

HashSet<T> hs = new HashSet<T>(filtered);
HashSet<T> hs2 = new HashSet<T>(narrowlyFiltered);
hs.IsSubSetOf(hs2); //<- booleans saying true or false

否则，这个问题一般是undecidable problem。尽管有一些启发式方法可以适用于 许多 种情况。例如，您可以尝试使用旨在在编译时推断出这一点的代码协定。

证明：

正式的变体是：给定两个图灵机（方法、委托、指针），第一种语言中包含的每个字符串是否都包含在第二种语言中？
不可判定
证明：假设它是可判定的，EQ_TM 将是可判定的：只需首先验证第一个图灵机是否是第二个图灵机的子集，反之亦然。如果两者都是子集，我们知道它们接受相同的字符串集。

换句话说，如果你能做到这一点，你也可以推断出两个函数是否产生相同的结果，which cannot be implemented。

Answer 2

您必须将每个 Expression 分解为所有可能的继承类型（MethodCallExpression、ConditionalExpression 等），然后并行执行每个分解并检查每个可能的参数...编写代码会有点长...您可以通过ExpressionEqualityComparer 启发自己

Answer 3

看看Specification design pattern

一旦它被实现，那么在这种情况下你的规范就变成了

public class PersonNamedOlderThanSpecification : CompositeSpecification<Person>
{
    private string name;
    private int age;

    public PersonNamedOlderThanSpecification(string name, int age)
    {
        this.name = name;
        this.age = age;
    }


    public override bool IsSatisfiedBy(Person entity)
    {
        return (entity.Name.Contains(this.name)) && (entity.Age > age);
    }
}

那么你可以这样使用它：

var personSpecs = new PersonNamedOlderThanSpecification("So", 28);
var personSpecs2 = new PersonNamedOlderThanSpecification("Some", 36);

var filtered = people.FindAll(x => personSpecs.IsSatisfiedBy(x));
var adjusted = people.FindAll(x => personSpecs2.IsSatisfiedBy(x));

Answer 4

你可以试试这个：

var people = new List<Person>
{
     new Person {FullName = "Some Dude", Age = 45},
     new Person {FullName = "Another Dude", Age = 28},
     new Person {FullName = "Some Other Dude", Age = 36}
};

var filtered = people.Where(person => person.Age > 28 && person.FullName.StartsWith("So"));
var narrowlyFiltered = people.Where(person => person.Age > 36 && person.FullName.StartsWith("Some"));

var intersection = filtered.Intersect(narrowlyFiltered);
if (intersection != null)
{
    if (intersection.Count() > 0)
    {
        //narrowlyFiltered is subset of filtered
    }
}

Answer 5

这完全取决于您如何衡量相等的权重，比较表达式时更重要的是什么等。 例如，如果您有完全不同的过滤器，那么您在实际执行之前可能不会知道查询差异。

要完全控制您的比较，请创建一个具有一些可用于过滤的属性的过滤器类，然后构建表达式并使用此类而不是使用访问者进行比较。 您可以准备通用函数来比较整数、整数对（用于范围）等。

我没有检查下面的代码，但它应该是一个好的开始。

public class PersonFilter:  IComparable<PersonFilter>
{
    public int? MinAge { get; set; }

    public int? MaxAge { get; set; }

    public string NamePrefix { get; set; }

    public Expression<Predicate<Person>> Filter
    {
        return people => people.Where(person => (!MinAge.HasValue || person.Age > MinAge.Value) && 
            (!MaxAge.HasValue || person.Age < MaxAge.Value) && 
            (string.IsNullOrEmpty(NamePrefix) || person.FullName.StartsWith(NamePrefix))
    }

    // -1 if this filter is filtering more than the other
    public int CompareTo(PersonFilter other)
    {
        var balance = 0; // equal
        if(MinAge.HasValue != other.MinAge.HasValue)
        {
            balance += MinAge.HasValue ? -1 : 1;
        }
        else if(MinAge.HasValue)
        {
            balance += MinAge.Value.CompareTo(other.MinAge.Value) ?
        }
        if(string.IsNullOrEmpty(NamePrefix) != string.IsNullOrEmpty(other.NamePrefix))
        {
            balance += string.IsNullOrEmpty(NamePrefix) ? -1 : 1;
        }
        else if(!string.IsNullOrEmpty(NamePrefix))
        {
            if(NamePrefix.StartsWith(other.NamePrefix))
            {
                balance -= 1;
            }
            else if(other.NamePrefix.StartsWith(NamePrefix))
            {
                balance += 1;
            }
            else
            {
                // if NamePrefix is the same or completely different let's assume both filters are equal
            }
        }
        return balance;
    }

    public bool IsSubsetOf(PersonFilter other)
    {
        if(MinAge.HasValue != other.MinAge.HasValue)
        {
            if(other.MinAge.HasValue)
            {
                return false;
            }
        }
        else if(MinAge.HasValue && MinAge.Value < other.MinAge.Value)
        {
            return false;
        }

        if(string.IsNullOrEmpty(NamePrefix) != string.IsNullOrEmpty(other.NamePrefix))
        {
            if(!string.IsNullOrEmpty(other.NamePrefix))
            {
                return false;
            }
        }
        else if(!string.IsNullOrEmpty(NamePrefix))
        {
            if(!NamePrefix.StartsWith(other.NamePrefix))
            {
            return false;
            }
        }

        return true;
    }
}