Сравните PropertyInfo с Type.GetProperties() и лямбда-выражениями

При создании моей системы тестирования я обнаружил странную проблему.

Я хочу создать статический класс, который позволит мне сравнивать объекты одного и того же типа по их свойствам, но с возможностью игнорировать некоторые из них.

Я хочу иметь простой свободный API для этого, поэтому вызов типа TestEqualityComparer.Equals(first.Ignore(x=>x.Id).Ignore(y=>y.Name), second); будет возвращать true, если заданные объекты равны для каждого свойства, кроме Id и Name (они не будут проверены на равенство).

Вот мой код. Конечно, это тривиальный пример (с некоторыми очевидными перегрузками методов, отсутствующих), но я хотел извлечь самый простой код. Сценарий реального случая немного сложнее, поэтому я не хочу менять подход.

Метод FindProperty является почти копией в библиотеке AutoMapper.

Обертка объектов для свободного API:

public class TestEqualityHelper<T>
{
    public List<PropertyInfo> IgnoredProps = new List<PropertyInfo>();
    public T Value;
}

Свободный материал:

public static class FluentExtension
{
    //Extension method to speak fluently. It finds the property mentioned
    // in 'ignore' parameter and adds it to the list.
    public static TestEqualityHelper<T> Ignore<T>(this T value,
         Expression<Func<T, object>> ignore)
    {
        var eh = new TestEqualityHelper<T> { Value = value };

        //Mind the magic here!
        var member = FindProperty(ignore);
        eh.IgnoredProps.Add((PropertyInfo)member);
        return eh;
    }

    //Extract the MemberInfo from the given lambda
    private static MemberInfo FindProperty(LambdaExpression lambdaExpression)
    {
        Expression expressionToCheck = lambdaExpression;

        var done = false;

        while (!done)
        {
            switch (expressionToCheck.NodeType)
            {
                case ExpressionType.Convert:
                    expressionToCheck 
                        = ((UnaryExpression)expressionToCheck).Operand;
                    break;
                case ExpressionType.Lambda:
                    expressionToCheck
                        = ((LambdaExpression)expressionToCheck).Body;
                    break;
                case ExpressionType.MemberAccess:
                    var memberExpression 
                        = (MemberExpression)expressionToCheck;

                    if (memberExpression.Expression.NodeType 
                          != ExpressionType.Parameter &&
                        memberExpression.Expression.NodeType 
                          != ExpressionType.Convert)
                    {
                        throw new Exception("Something went wrong");
                    }

                    return memberExpression.Member;
                default:
                    done = true;
                    break;
            }
        }

        throw new Exception("Something went wrong");
    }
}

Фактическое сравнение:

public static class TestEqualityComparer
{
    public static bool MyEquals<T>(TestEqualityHelper<T> a, T b)
    {
        return DoMyEquals(a.Value, b, a.IgnoredProps);
    }

    private static bool DoMyEquals<T>(T a, T b,
        IEnumerable<PropertyInfo> ignoredProperties)
    {
        var t = typeof(T);
        IEnumerable<PropertyInfo> props;

        if (ignoredProperties != null && ignoredProperties.Any())
        {
            //THE PROBLEM IS HERE!
            props =
                t.GetProperties(BindingFlags.Instance | BindingFlags.Public)
                    .Except(ignoredProperties);
        }
        else
        {
            props = 
                t.GetProperties(BindingFlags.Instance | BindingFlags.Public);
        }
        return props.All(f => f.GetValue(a, null).Equals(f.GetValue(b, null)));
    }
}

В основном это.

И вот два тестовых фрагмента, первый работает, второй не удается:

//These are the simple objects we'll compare
public class Base
{
    public decimal Id { get; set; }
    public string Name { get; set; }
}
public class Derived : Base
{    }

[TestMethod]
public void ListUsers()
{
   //TRUE
   var f = new Base { Id = 5, Name = "asdas" };
   var s = new Base { Id = 6, Name = "asdas" };
   Assert.IsTrue(TestEqualityComparer.MyEquals(f.Ignore(x => x.Id), s));

   //FALSE
   var f2 = new Derived { Id = 5, Name = "asdas" };
   var s2 = new Derived { Id = 6, Name = "asdas" };
   Assert.IsTrue(TestEqualityComparer.MyEquals(f2.Ignore(x => x.Id), s2));
}

Проблема заключается в методе Except в DoMyEquals.

Свойства, возвращаемые FindProperty, не равны значениям, возвращаемым Type.GetProperties. Разница, которую я вижу, находится в PropertyInfo.ReflectedType.

• независимо от типа моих объектов, FindProperty сообщает мне, что отраженный тип Base.

• свойства, возвращаемые Type.GetProperties, имеют значение ReflectedType Base или Derived, в зависимости от типа фактических объектов.

Я не знаю, как его решить. Я могу проверить тип параметра в лямбда, но на следующем шаге я хочу разрешить конструкции типа Ignore(x=>x.Some.Deep.Property), поэтому, вероятно, этого не будет.

Любое предложение о том, как сравнить PropertyInfo или как получить их от lambdas должным образом, будет оценено.