表达式树中的相等性没有使用正确的操作符重载

我得到了表达式树和操作符重载的一些奇怪的问题(特别是==和!=操作符)。

我正在使用来自Marc Gravell的答案之一的MemberwiseComparer，或多或少是一个

public static class MemberComparer
{
    public static bool Equal<T>(T x, T y)
    {
        return EqualComparerCache<T>.Compare(x, y);
    }
    static class EqualComparerCache<T>
    {
        internal static readonly Func<T, T, bool> Compare = (a, b) => true;
        static EqualComparerCache()
        {
            var members = typeof(T).GetTypeInfo().DeclaredProperties.Cast<MemberInfo>()
                .Concat(typeof(T).GetTypeInfo().DeclaredFields.Where(p => !p.IsStatic && p.IsPublic).Cast<MemberInfo>());
            var x = Expression.Parameter(typeof(T), "x");
            var y = Expression.Parameter(typeof(T), "y");
            Expression body = null;
            foreach (var member in members)
            {
                Expression memberEqual;
                if (member is FieldInfo)
                {
                    memberEqual = Expression.Equal(
                        Expression.Field(x, (FieldInfo)member),
                        Expression.Field(y, (FieldInfo)member));
                }
                else if (member is PropertyInfo)
                {
                    memberEqual = Expression.Equal(
                        Expression.Property(x, (PropertyInfo)member),
                        Expression.Property(y, (PropertyInfo)member));
                }
                else
                {
                    throw new NotSupportedException(member.GetType().GetTypeInfo().Name);
                }
                body = body == null ? memberEqual : Expression.AndAlso(body, memberEqual);
            }
            if (body != null)
            {
                var lambda = Expression.Lambda<Func<T, T, bool>>(body, x, y);
                Compare = lambda.Compile();
            }
        }
    }
}

和一个基类ValueObject<T>，作为值对象的基类。

public class ValueObject<T> : IEquatable<T> where T : ValueObject<T>
{
    public virtual bool Equals(T other)
    {
        if (ReferenceEquals(this, other))
            return true;
        return MemberComparer.Equal<T>((T)this, other);
    }
    public override bool Equals(object obj)
    {
        return Equals(obj as T);
    }
    public override int GetHashCode()
    {
        return MemberComparer.GetHashCode((T)this);
    }
    public static bool operator ==(ValueObject<T> left, ValueObject<T> right)
    {
        // If both are null, or both are same instance, return true.
        if (ReferenceEquals(left, right))
        {
            return true;
        }
        // If one is null, but not both, return false.
        if (((object)left == null) || ((object)right == null))
        {
            return false;
        }
        return left.Equals(right);
    }
    public static bool operator !=(ValueObject<T> left, ValueObject<T> right)
    {
        return !(left == right);
    }
}

一般来说，这对于实现IEquatable<T>或标量类型和/或字符串的类工作得很好。但是，当类包含实现ValueObject<T>的类的属性时，比较失败。

public class Test : ValueObject<Test>
{
    public string Value { get; set; }
}
public class Test2 : ValueObject<Test2>
{
    public Test Test { get; set; }
}

当比较Test和Test，它工作得很好。

var test1 = new Test { Value = "TestValue"; }
var test2 = new Test { Value = "TestValue"; }
Assert.True(test1==test2); // true
Assert.Equals(test1, test2); // true

但是当比较Test2时，它失败了:

var nestedTest1 = new Test2 { Test = new Test { Value = "TestValue"; } }
var nestedTest2 = new Test2 { Test = new Test { Value = "TestValue"; } }
Assert.True(nestedTest1==nestedTest2 ); // false
Assert.Equals(nestedTest1, nestedTest2 ); // false
// Second Test with referenced Test object
var test = new Test { Value = "TestValue"; }
var nestedTest1 = new Test2 { Test = test }
var nestedTest2 = new Test2 { Test = test }
Assert.True(nestedTest1==nestedTest2 ); // true
Assert.Equals(nestedTest1, nestedTest2 ); // true

==操作符覆盖被Test2类调用，但不被Test类调用。当nestedTest1和nestedTest2引用同一个Test对象时，它工作。因此，在构建和编译表达式时不会调用==重载。

我找不到它为什么会忽略它的原因。这是没有人注意到的Roslyn的一些变化，还是表达式树生成有问题?

当然，我可以重写表达式树生成来调用.Equals方法，但这会增加更多的复杂性(和额外的null检查)。但实际的问题是，为什么编译表达式树不使用==重载，以及如何使其工作?

// this is used by Expression.Equal (it does not search for base type)
var m = typeof(Test).GetMethod("op_Equality", 
            BindingFlags.Static 
            | BindingFlags.Public | BindingFlags.NonPublic);
//m is null because op_Equality is not declared on "Test"
var m = typeof(ValueObject<>).GetMethod("op_Equality", 
            BindingFlags.Static 
            | BindingFlags.Public | BindingFlags.NonPublic);
// m is not null

MethodInfo equalsOperator = FindMethod(memberType, "op_Equality", false);
equalityExpression = Expression.Equal(
    Expression.Property(left, memberInfo),
    Expression.Property(right, memberInfo),
    false,
    equalsOperator);
... 
private static MethodInfo FindMethod(Type type, string methodName, bool throwIfNotFound = true)
{
    TypeInfo typeInfo = type.GetTypeInfo();
    // TODO: Improve to search methods with a specific signature and parameters
    while (typeInfo != null)
    {
        IEnumerable<MethodInfo> methodInfo = typeInfo.GetDeclaredMethods(methodName);
        if (methodInfo.Any())
            return methodInfo.First();
        typeInfo = typeInfo.BaseType?.GetTypeInfo();
    }
    if (!throwIfNotFound)
        return null;
    throw new InvalidOperationException($"Type '{type.GetTypeInfo().FullName}' has no '{methodName}' method.");
}