Cómo comprobar rápidamente si los objetos de transferencia de datos dos tienen iguales propiedades en C #?
https://stackoverflow.com/questions/986572
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPregunta
Tengo estos objetos de transferencia de datos:
public class Report
{
public int Id { get; set; }
public int ProjectId { get; set; }
//and so on for many, many properties.
}
No quiero escribir
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;
}
¿Hay una manera más rápida para probar si dos objetos con propiedades únicas tienen los mismos valores (algo que no requiere una línea de código o de una expresión lógica por propiedad?)
El cambio a estructuras no es una opción.
Solución
¿Qué hay de alguna reflexión, tal vez usando Expression.Compile() para el rendimiento? (Tenga en cuenta la ctor estática aquí asegura que sólo compila una vez por 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();
}
}
}
Editar: actualizado para manejar campos también:
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();
}
}
}
}
Otros consejos
contestado originalmente en ( pregunta 1831747 )
MemberwiseEqualityComparer para ver si se ajusta a sus necesidades.
Es muy fácil de usar y muy eficiente. Utiliza IL-emiten para generar la totalidad de los iguales y función GetHashCode en la primera ejecución (una vez para cada tipo utilizado). Se comparará cada campo (privado o público) del objeto determinado, utilizando el comparador de igualdad predeterminado para ese tipo (EqualityComparer.Default). Hemos estado utilizando en la producción durante un tiempo y parece estable, pero voy a dejar ninguna garantía =)
Se ocupa de todos aquellos casos pescy de borde que rara vez se piensa cuando está rodando su propio método equals (es decir, no se puede comparador de su propio objeto con nula a menos que haya en caja en un objeto primero y hay mucho de cuestiones más relacionadas nulos).
He estado queriendo escribir un post sobre ello, pero no han llegado en torno a ella todavía. El código es indocumentado un poco, pero si te gusta lo que podría limpiarlo un poco.
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);
}
El MemberwiseEqualityComparer es liberado bajo la licencia MIT meaining se puede hacer prácticamente todo lo que quieras con él, incluyendo su uso en soluciones propietarias sin cambiar un poco que la concesión de licencias.
He ampliado código de Marc ser una aplicación de pleno derecho IEqualityComparer para mi propio uso, y pensamos que esto puede ser útil a otros en el futuro:
/// <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>
{
// http://stackoverflow.com/questions/986572/hows-to-quick-check-if-data-transfer-two-objects-have-equal-properties-in-c/986617#986617
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);
}
}
Por desgracia que va a tener que escribir el método para comparar los valores de los campos. System.ValueType está construido para utilizar la reflexión y comparar los valores de campo de un struct pero incluso esto es desaconsejable debido al bajo rendimiento. Lo mejor que puede hacer es reemplazar el método Equals y también implementar el IEquatable<T> interfaz para una sobrecarga de Equals inflexible.
Mientras que usted está en él, puede ser que también proporciona una buena anulación GetHashCode, así como complemento de la aplicación Equals. Todos estos pasos se consideran buenas prácticas.
Usted tendrá que utilizar la reflexión para hacer esto, por favor, siga este enlace -> Comparando objeto propiedades en c #
