Как быстро проверить, имеют ли два объекта передачи данных одинаковые свойства в C #? - PullRequest
Новая
       11

Как быстро проверить, имеют ли два объекта передачи данных одинаковые свойства в C #?

26 голосов
/ 12 июня 2009

У меня есть следующие объекты передачи данных: 

public class Report 
{
    public int Id { get; set; }
    public int ProjectId { get; set; }
    //and so on for many, many properties.
}

Я не хочу писать 

public bool areEqual(Report a, Report b)
{
    if (a.Id != b.Id) return false;
    if (a.ProjectId != b.ProjectId) return false;
    //Repeat ad nauseum
    return true;
}

Существует ли более быстрый способ проверки, если два объекта с единственными свойствами имеют одинаковые значения (то, что не требует одной строки кода или одного логического выражения на свойство?)

Переключение на структуры не вариант.

Ответы [ 5 ]

66 голосов
/ 12 июня 2009

Как насчет рефлексии, возможно, используя Expression.Compile() для производительности? (обратите внимание, что статический ctor здесь гарантирует, что мы компилируем его только один раз за T): 

using System;
using System.Linq.Expressions;

public class Report {
    public int Id { get; set; }
    public int ProjectId { get; set; }
    static void Main() {
        Report a = new Report { Id = 1, ProjectId = 13 },
            b = new Report { Id = 1, ProjectId = 13 },
            c = new Report { Id = 1, ProjectId = 12 };
        Console.WriteLine(PropertyCompare.Equal(a, b));
        Console.WriteLine(PropertyCompare.Equal(a, c));
    }
}
static class PropertyCompare {
    public static bool Equal<T>(T x, T y) {
        return Cache<T>.Compare(x, y);
    }
    static class Cache<T> {
        internal static readonly Func<T, T, bool> Compare;
        static Cache() {
            var props = typeof(T).GetProperties();
            if (props.Length == 0) {
                Compare = delegate { return true; };
                return;
            }
            var x = Expression.Parameter(typeof(T), "x");
            var y = Expression.Parameter(typeof(T), "y");

            Expression body = null;
            for (int i = 0; i < props.Length; i++) {
                var propEqual = Expression.Equal(
                    Expression.Property(x, props[i]),
                    Expression.Property(y, props[i]));
                if (body == null) {
                    body = propEqual;
                } else {
                    body = Expression.AndAlso(body, propEqual);
                }
            }
            Compare = Expression.Lambda<Func<T, T, bool>>(body, x, y)
                          .Compile();
        }
    }
}

Редактировать: обновлено, чтобы обрабатывать поля тоже: 

static class MemberCompare
{
    public static bool Equal<T>(T x, T y)
    {
        return Cache<T>.Compare(x, y);
    }
    static class Cache<T>
    {
        internal static readonly Func<T, T, bool> Compare;
        static Cache()
        {
            var members = typeof(T).GetProperties(
                BindingFlags.Instance | BindingFlags.Public)
                .Cast<MemberInfo>().Concat(typeof(T).GetFields(
                BindingFlags.Instance | BindingFlags.Public)
                .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;
                switch (member.MemberType)
                {
                    case MemberTypes.Field:
                        memberEqual = Expression.Equal(
                            Expression.Field(x, (FieldInfo)member),
                            Expression.Field(y, (FieldInfo)member));
                        break;
                    case MemberTypes.Property:
                        memberEqual = Expression.Equal(
                            Expression.Property(x, (PropertyInfo)member),
                            Expression.Property(y, (PropertyInfo)member));
                        break;
                    default:
                        throw new NotSupportedException(
                            member.MemberType.ToString());
                }
                if (body == null)
                {
                    body = memberEqual;
                }
                else
                {
                    body = Expression.AndAlso(body, memberEqual);
                }
            }
            if (body == null)
            {
                Compare = delegate { return true; };
            }
            else
            {
                Compare = Expression.Lambda<Func<T, T, bool>>(body, x, y)
                              .Compile();
            }
        }
    }
}
4 голосов
/ 14 мая 2013

Я расширил код Марка до полноценной реализации IEqualityComparer для своих собственных нужд и подумал, что это может быть полезно для других в будущем: 

/// <summary>
/// An <see cref="IEqualityComparer{T}"/> that compares the values of each public property.
/// </summary>
/// <typeparam name="T"> The type to compare. </typeparam>
public class PropertyEqualityComparer<T> : IEqualityComparer<T>
{
    // /715180/kak-bystro-proverit-imeyt-li-dva-obekta-peredachi-dannyh-odinakovye-svoistva-v-c#715189

    static class EqualityCache
    {
        internal static readonly Func<T, T, bool> Compare;
        static EqualityCache()
        {
            var props = typeof(T).GetProperties();
            if (props.Length == 0)
            {
                Compare = delegate { return true; };
                return;
            }
            var x = Expression.Parameter(typeof(T), "x");
            var y = Expression.Parameter(typeof(T), "y");

            Expression body = null;
            for (int i = 0; i < props.Length; i++)
            {
                var propEqual = Expression.Equal(
                    Expression.Property(x, props[i]),
                    Expression.Property(y, props[i]));
                if (body == null)
                {
                    body = propEqual;
                }
                else
                {
                    body = Expression.AndAlso(body, propEqual);
                }
            }
            Compare = Expression.Lambda<Func<T, T, bool>>(body, x, y).Compile();
        }
    }

    /// <inheritdoc/>
    public bool Equals(T x, T y)
    {
        return EqualityCache.Compare(x, y);
    }

    static class HashCodeCache
    {
        internal static readonly Func<T, int> Hasher;
        static HashCodeCache()
        {
            var props = typeof(T).GetProperties();
            if (props.Length == 0)
            {
                Hasher = delegate { return 0; };
                return;
            }
            var x = Expression.Parameter(typeof(T), "x");

            Expression body = null;
            for (int i = 0; i < props.Length; i++)
            {
                var prop = Expression.Property(x, props[i]);
                var type = props[i].PropertyType;
                var isNull = type.IsValueType ? (Expression)Expression.Constant(false, typeof(bool)) : Expression.Equal(prop, Expression.Constant(null, type));
                var hashCodeFunc = type.GetMethod("GetHashCode", BindingFlags.Instance | BindingFlags.Public);
                var getHashCode = Expression.Call(prop, hashCodeFunc);
                var hashCode = Expression.Condition(isNull, Expression.Constant(0, typeof(int)), getHashCode);

                if (body == null)
                {
                    body = hashCode;
                }
                else
                {
                    body = Expression.ExclusiveOr(Expression.Multiply(body, Expression.Constant(typeof(T).AssemblyQualifiedName.GetHashCode(), typeof(int))), hashCode);
                }
            }
            Hasher = Expression.Lambda<Func<T, int>>(body, x).Compile();
        }
    }

    /// <inheritdoc/>
    public int GetHashCode(T obj)
    {
        return HashCodeCache.Hasher(obj);
    }
}
4 голосов
/ 02 декабря 2009

Первоначально ответили на ( вопрос 1831747 )

Проверьте мой MemberwiseEqualityComparer , чтобы увидеть, соответствует ли он вашим потребностям.

Это действительно удобно и довольно эффективно. Он использует IL-emit для генерации всей функции Equals и GetHashCode при первом запуске (один раз для каждого используемого типа). Он будет сравнивать каждое поле (частное или общедоступное) данного объекта с помощью средства сравнения по умолчанию для этого типа (EqualityComparer.Default). Некоторое время мы использовали его в производстве, и он кажется стабильным, но я не оставлю никаких гарантий =)

Он заботится обо всех тех крайних случаях, о которых вы редко думаете, когда вы катите свой собственный метод equals (то есть вы не можете сравнить свой собственный объект с нулем, если вы сначала не поместили его в объект и многие другие вопросы, связанные с нулями).

Я намеревался написать в блоге об этом, но еще не дошел до этого. Код немного недокументирован, но если вам понравится, я могу немного его почистить. 

public override int GetHashCode()
{
    return MemberwiseEqualityComparer<Foo>.Default.GetHashCode(this);
}

public override bool Equals(object obj)
{
    if (obj == null)
        return false;

    return Equals(obj as Foo);
}

public override bool Equals(Foo other)
{
    return MemberwiseEqualityComparer<Foo>.Default.Equals(this, other);
}

MemberwiseEqualityComparer выпускается под лицензией MIT , что означает, что вы можете делать с ним практически все, что захотите, в том числе использовать его в проприетарных решениях, не меняя лицензию.

2 голосов
/ 12 июня 2009

К сожалению, вам придется написать метод для сравнения значений полей. System.ValueType создан для использования отражения и сравнения значений поля struct, но даже это нежелательно из-за низкой производительности. Лучше всего переопределить метод Equals, а также реализовать интерфейс IEquatable<T> для сильно типизированной перегрузки Equals.

Пока вы это делаете, вы можете также предоставить хорошее GetHashCode переопределение, чтобы дополнить реализацию Equals. Все эти шаги считаются хорошей практикой.

1 голос
/ 12 июня 2009

Для этого вам нужно использовать отражение, перейдите по этой ссылке -> Сравнение свойств объекта в c #

...