GenericEqualityComparer
Creating support for Equality comparison of classes in C# can become repititive. In this article, we will look at a Generic equality comparer that can be used for classes to do equality comparison.
Please note that we are meaning here value comparison. Structs and records support via built-in functionality such a value equality comparison. For classes, it depends on what you mean by equality comparison.
Usually it means the public properties, but additional state such as private properties and fields can also be considered.
Github repo with this source code
https://github.com/toreaurstadboss/GenericEqualityComparer
A reflection-based IEqualityComparer<T> that compares two objects
by their member values instead of by reference. Useful for plain C# classes
that don't override Equals and GetHashCode themselves.
1 — The problem it solves
In C#, class instances are compared by reference by default.
Two objects with identical data are not equal unless they are the same object in memory.
var car1 = new Car { Make = "Toyota", Model = "Camry", Year = 2020 };
var car2 = new Car { Make = "Toyota", Model = "Camry", Year = 2020 };
Console.WriteLine(car1 == car2); // False — different object references
Console.WriteLine(car1.Equals(car2)); // False — same reason
GenericEqualityComparer<T> solves this without touching the class itself.
It uses reflection to compare each property (and optionally each field) value by value.
But it also uses member expressions compiled into delegates to provide fast member value lookups.
This makes the generic equality comparer used here possible to use inside collections with many items.
Lets first look at the GenericEqualityComparer source code. It is a generic class.
GenericEqualityComparer.cs
using System.Diagnostics.CodeAnalysis;
using System.Linq.Expressions;
using System.Reflection;
namespace GenericEqualityComparer.Lib
{
/// <summary>
/// A reflection-based <see cref="IEqualityComparer{T}"/> that compares instances of
/// <typeparamref name="T"/> by their members rather than by reference.
/// This is intended for use with classes that do not implement their own value-based equality semantics, and is not recommended for performance-sensitive scenarios.
/// Types such as structs and records already have built-in value equality semantics and should not require this comparer.
/// </summary>
/// <typeparam name="T">The type to compare. Must be a reference type.</typeparam>
/// <remarks>
/// By default only public instance properties are compared. Pass the constructor flags to
/// also include private properties and/or fields (public or private).
/// </remarks>
public class GenericEqualityComparer<T> : IEqualityComparer<T> where T : class
{
private List<Func<T, object>> _propertyGetters = new List<Func<T, object>>(); // Cache of compiled delegates for accessing the configured properties of T, used to avoid the performance overhead of reflection during comparisons.
private List<Func<T, object>> _fieldGetters = new List<Func<T, object>>(); // Cache of compiled delegates for accessing the configured fields of T, used to avoid the performance overhead of reflection during comparisons.
/// <summary>
/// Initialises the comparer and builds the member accessor cache.
/// </summary>
/// <param name="includeFields">When <see langword="true"/>, public instance fields are included in the comparison.</param>
/// <param name="includePrivateProperties">When <see langword="true"/>, private instance properties are included in the comparison.</param>
/// <param name="includePrivateFields">When <see langword="true"/>, private instance fields are included in the comparison. Also enables public field comparison.</param>
public GenericEqualityComparer(bool includeFields = false, bool includePrivateProperties = false, bool includePrivateFields = false)
{
CreatePropertyGetters(includePrivateProperties);
if (includeFields || includePrivateFields)
{
CreateFieldGetters(includePrivateFields);
}
}
private void CreatePropertyGetters(bool includePrivateProperties)
{
var bindingFlags = BindingFlags.Instance | BindingFlags.Public;
if (includePrivateProperties)
{
bindingFlags |= BindingFlags.NonPublic;
}
var props = typeof(T).GetProperties(bindingFlags).Where(m => m.GetMethod != null).ToList();
foreach (var prop in props)
{
//Builds the Expression<Func<T, object>> for the property getter and compiles it into a Func<T, object> delegate, which is cached for later use.
ParameterExpression parameter = Expression.Parameter(typeof(T), "p");
MemberExpression propertyExpression = Expression.Property(parameter, prop.Name);
Expression boxedPropertyExpression = Expression.Convert(propertyExpression, typeof(object));
Expression<Func<T, object>> propertyGetter = Expression.Lambda<Func<T, object>>(boxedPropertyExpression, parameter);
_propertyGetters.Add(propertyGetter.Compile());
}
}
private void CreateFieldGetters(bool includePrivateFields)
{
var bindingFlags = BindingFlags.Instance | BindingFlags.Public;
if (includePrivateFields)
{
bindingFlags |= BindingFlags.NonPublic;
}
var fields = typeof(T).GetFields(bindingFlags).ToList();
foreach (var field in fields)
{
// Builds the Expression<Func<T, object>> for the field getter and compiles it into a Func<T, object> delegate, which is cached for later use.
ParameterExpression parameter = Expression.Parameter(typeof(T), "f");
MemberExpression fieldExpression = Expression.Field(parameter, field.Name);
Expression boxedPropertyExpression = Expression.Convert(fieldExpression, typeof(object));
Expression<Func<T, object>> fieldGetter = Expression.Lambda<Func<T, object>>(boxedPropertyExpression, parameter);
_fieldGetters.Add(fieldGetter.Compile());
}
}
/// <summary>
/// Determines whether <paramref name="x"/> and <paramref name="y"/> are equal by comparing
/// each configured member in turn.
/// </summary>
/// <param name="x">The first object to compare.</param>
/// <param name="y">The second object to compare.</param>
/// <returns>
/// <see langword="true"/> when all configured members are equal;
/// <see langword="false"/> when any member differs, or either argument is <see langword="null"/>.
/// </returns>
public bool Equals(T? x, T? y)
{
if (x == null || y == null)
{
return false;
}
if (ReferenceEquals(x, y))
{
return true;
}
if (x.GetType() != y.GetType())
{
return false;
}
foreach (var propAccessor in _propertyGetters)
{
var xv = propAccessor(x);
var yv = propAccessor(y);
if (!xv.Equals(yv))
{
return false;
}
}
foreach (var fieldAccessor in _fieldGetters)
{
var xv = fieldAccessor(x);
var yv = fieldAccessor(y);
if (!xv.Equals(yv))
{
return false;
}
}
return true;
}
/// <summary>
/// Returns an <see cref="EqualityWrapper{T}"/> for <paramref name="value"/> so that
/// <c>==</c> and <c>!=</c> use this comparer's configured equality semantics.
/// </summary>
/// <param name="value">The value to wrap.</param>
/// <returns>An <see cref="EqualityWrapper{T}"/> bound to this comparer instance.</returns>
public EqualityWrapper<T> For(T value) => new EqualityWrapper<T>(value, this);
/// <summary>
/// Returns a hash code for <paramref name="obj"/> derived from the same configured members
/// used by <see cref="Equals(T, T)"/>.
/// </summary>
/// <param name="obj">The object to hash.</param>
/// <returns>A hash code consistent with the configured equality semantics.</returns>
public int GetHashCode([DisallowNull] T obj)
{
int hash = 0;
var propertyValues = _propertyGetters.Select(p => p(obj)).ToList();
for (int i = 0; i < propertyValues.Count; i += 8)
{
hash = HashCode.Combine(hash,
propertyValues.ElementAtOrDefault(i),
propertyValues.ElementAtOrDefault(i + 1),
propertyValues.ElementAtOrDefault(i + 2),
propertyValues.ElementAtOrDefault(i + 3),
propertyValues.ElementAtOrDefault(i + 4),
propertyValues.ElementAtOrDefault(i + 5),
propertyValues.ElementAtOrDefault(i + 6));
}
if (_fieldGetters.Any())
{
var fieldValues = _fieldGetters.Select(f => f(obj)).ToList();
for (int i = 0; i < fieldValues.Count; i += 8)
{
hash = HashCode.Combine(hash,
fieldValues.ElementAtOrDefault(i),
fieldValues.ElementAtOrDefault(i + 1),
fieldValues.ElementAtOrDefault(i + 2),
fieldValues.ElementAtOrDefault(i + 3),
fieldValues.ElementAtOrDefault(i + 4),
fieldValues.ElementAtOrDefault(i + 5),
fieldValues.ElementAtOrDefault(i + 6));
}
}
return hash;
}
}
}
The method
For accepts a
object instance of type T and returns a
EqualityWrapper struct that allows the usage of operator
== and
!=
EqualityWrapper.cs
namespace GenericEqualityComparer.Lib;
/// <summary>
/// Pairs a value of type <typeparamref name="T"/> with a <see cref="GenericEqualityComparer{T}"/>
/// so that <c>==</c> and <c>!=</c> use the comparer's configured equality semantics instead of
/// reference equality.
/// </summary>
/// <typeparam name="T">The type of the wrapped value. Must be a reference type.</typeparam>
/// <remarks>
/// Obtain an instance via <see cref="GenericEqualityComparer{T}.For"/>:
/// <code>comparer.For(car1) == comparer.For(car2)</code>
/// </remarks>
public readonly struct EqualityWrapper<T> where T : class
{
private readonly T _value;
private readonly GenericEqualityComparer<T> _comparer;
internal EqualityWrapper(T value, GenericEqualityComparer<T> comparer)
{
_value = value;
_comparer = comparer;
}
/// <summary>
/// Returns <see langword="true"/> when <paramref name="left"/> and <paramref name="right"/>
/// are considered equal by their shared comparer.
/// </summary>
public static bool operator ==(EqualityWrapper<T> left, EqualityWrapper<T> right)
=> left._comparer.Equals(left._value, right._value);
/// <summary>
/// Returns <see langword="true"/> when <paramref name="left"/> and <paramref name="right"/>
/// are not considered equal by their shared comparer.
/// </summary>
public static bool operator !=(EqualityWrapper<T> left, EqualityWrapper<T> right)
=> !(left == right);
/// <inheritdoc/>
public override bool Equals(object? obj)
=> obj is EqualityWrapper<T> other && this == other;
/// <inheritdoc/>
public override int GetHashCode()
=> _comparer.GetHashCode(_value);
}
2 — Quick start
2.1 Compare public properties
using GenericEqualityComparer.Lib;
var comparer = new GenericEqualityComparer<Car>();
var car1 = new Car { Make = "Toyota", Model = "Camry", Year = 2020 };
var car2 = new Car { Make = "Toyota", Model = "Camry", Year = 2020 };
var car3 = new Car { Make = "Toyota", Model = "Corolla", Year = 2020 };
Console.WriteLine(comparer.Equals(car1, car2)); // True — all properties match
Console.WriteLine(comparer.Equals(car1, car3)); // False — Model differs
2.2 Use it with LINQ or collections
Because GenericEqualityComparer<T> implements
IEqualityComparer<T> you can pass it directly to LINQ methods and
collection APIs that accept one.
var cars = new List<Car>
{
new Car { Make = "Toyota", Model = "Camry", Year = 2020 },
new Car { Make = "Toyota", Model = "Camry", Year = 2020 }, // duplicate
new Car { Make = "Toyota", Model = "Corolla", Year = 2021 },
};
var comparer = new GenericEqualityComparer<Car>();
// Distinct by value
var unique = cars.Distinct(comparer).ToList(); // 2 items
// GroupBy by value
var grouped = cars.GroupBy(c => c, comparer);
3 — Constructor options
The constructor accepts three optional boolean flags. All default to false.
| Parameter |
Type |
What it includes |
includeFields |
bool |
Public instance fields |
includePrivateProperties |
bool |
Private instance properties |
includePrivateFields |
bool |
Private instance fields (also enables public fields) |
3.1 Include private fields
Imagine a Car class that stores a secret assembly number in a private field:
public class Car
{
public string Make { get; set; } = string.Empty;
public string Model { get; set; } = string.Empty;
public int Year { get; set; }
// private — not visible to external code
private string _secretAssemblyNumber = string.Empty;
public void SetSecretAssemblyNumber(string number) => _secretAssemblyNumber = number;
}
var ford1 = new Car { Make = "Ford", Model = "Focus", Year = 2022 };
var ford2 = new Car { Make = "Ford", Model = "Focus", Year = 2022 };
ford1.SetSecretAssemblyNumber("ASM-001");
ford2.SetSecretAssemblyNumber("ASM-999"); // intentionally different
// Default comparer — only sees public properties, ignores the private field
var defaultComparer = new GenericEqualityComparer<Car>();
Console.WriteLine(defaultComparer.Equals(ford1, ford2)); // True (field ignored)
// Include private fields — now the hidden difference is detected
var deepComparer = new GenericEqualityComparer<Car>(includePrivateFields: true);
Console.WriteLine(deepComparer.Equals(ford1, ford2)); // False
3.2 Include private properties
The same idea applies when a class uses a private property as an internal identifier:
public class Bicycle
{
public string Brand { get; set; } = string.Empty;
public string Model { get; set; } = string.Empty;
private string FrameSerialNumber { get; set; } = string.Empty;
public void SetFrameSerialNumber(string sn) => FrameSerialNumber = sn;
}
var bike1 = new Bicycle { Brand = "Trek", Model = "FX3" };
var bike2 = new Bicycle { Brand = "Trek", Model = "FX3" };
bike1.SetFrameSerialNumber("SN-001");
bike2.SetFrameSerialNumber("SN-999");
var defaultComparer = new GenericEqualityComparer<Bicycle>();
Console.WriteLine(defaultComparer.Equals(bike1, bike2)); // True
var deepComparer = new GenericEqualityComparer<Bicycle>(includePrivateProperties: true);
Console.WriteLine(deepComparer.Equals(bike1, bike2)); // False
4 — EqualityWrapper<T> and the == / != operators
C# doesn't allow overloading == and != on a generic type
parameter T in an external comparer class. As a workaround,
GenericEqualityComparer<T> exposes a For(value) method
that returns an EqualityWrapper<T>. The wrapper
carries both the value and the comparer, so its == and !=
operators delegate to the comparer instead of defaulting to reference equality.
4.1 Basic operator usage
var comparer = new GenericEqualityComparer<Car>();
var car1 = new Car { Make = "Toyota", Model = "Camry", Year = 2020 };
var car2 = new Car { Make = "Toyota", Model = "Camry", Year = 2020 };
var car3 = new Car { Make = "Toyota", Model = "Corolla", Year = 2020 };
bool same = comparer.For(car1) == comparer.For(car2); // True
bool different = comparer.For(car1) != comparer.For(car3); // True
4.2 With private member detection
var deepComparer = new GenericEqualityComparer<Car>(includePrivateFields: true);
var ford1 = new Car { Make = "Ford", Model = "Focus", Year = 2022 };
var ford2 = new Car { Make = "Ford", Model = "Focus", Year = 2022 };
ford1.SetSecretAssemblyNumber("ASM-001");
ford2.SetSecretAssemblyNumber("ASM-999");
if (deepComparer.For(ford1) != deepComparer.For(ford2))
{
Console.WriteLine("Cars differ (private field detected)");
}
4.3 Consistent hashing
EqualityWrapper<T> also overrides GetHashCode()
so it stays consistent with ==. This means wrapped values can be used
safely as dictionary keys or in hash sets.
var comparer = new GenericEqualityComparer<Car>();
var car1 = new Car { Make = "Toyota", Model = "Camry", Year = 2020 };
var car2 = new Car { Make = "Toyota", Model = "Camry", Year = 2020 };
int hash1 = comparer.For(car1).GetHashCode();
int hash2 = comparer.For(car2).GetHashCode();
Console.WriteLine(hash1 == hash2); // True — equal objects, equal hashes
5 — When not to use it
Performance: The comparer uses reflection to discover members at construction
time (compiled to delegates for speed), but it is still a little slower than a hand-written
Equals. Avoid it in tight loops or hot paths.
-
Records — C# records already have value equality built in.
Use
== directly.
-
Structs — Same as records; value equality is the default.
-
Classes you own — Prefer overriding
Equals /
GetHashCode or implementing IEquatable<T>
for production code (due to performance). Use this comparer for tests, prototyping, or
third-party types you can't modify. Or if you just would like a simple way of providing value based equality checks, but in that case you should
really
consider a specific implementation.
In case you work with generated code or for got a large number of POCO classes (Data transfer objects) and want to avoid using inheritance or adding value equality of your existing code,
this code allows you adding value based equality, this code shown here should have you covered with a generic util class.
6 - Supported Frameworks
Please note that since we use
HashCode here, supported target frameworks are netstandard 2.1 and .netcore 2.1 or later.
In case you use .NET Framework 4.8 or earlier for example, you can provide a
GetHashCode implementation like the following:
GetHashCode that avoids using HashCode.Combine
We can instead use two selected prime numbers and multipliers to calculate a hash of the object's propertis and fields like the following:
public int GetHashCode([DisallowNull] T obj)
{
int hash = 0;
var propertyValues = _propertyGetters.Select(p => p(obj)).ToList();
for (int i = 0; i < propertyValues.Count; i += 8)
{
hash = Combine(hash,
propertyValues.ElementAtOrDefault(i),
propertyValues.ElementAtOrDefault(i + 1),
propertyValues.ElementAtOrDefault(i + 2),
propertyValues.ElementAtOrDefault(i + 3),
propertyValues.ElementAtOrDefault(i + 4),
propertyValues.ElementAtOrDefault(i + 5),
propertyValues.ElementAtOrDefault(i + 6));
}
if (_fieldGetters.Any())
{
var fieldValues = _fieldGetters.Select(f => f(obj)).ToList();
for (int i = 0; i < fieldValues.Count; i += 8)
{
hash = Combine(hash,
fieldValues.ElementAtOrDefault(i),
fieldValues.ElementAtOrDefault(i + 1),
fieldValues.ElementAtOrDefault(i + 2),
fieldValues.ElementAtOrDefault(i + 3),
fieldValues.ElementAtOrDefault(i + 4),
fieldValues.ElementAtOrDefault(i + 5),
fieldValues.ElementAtOrDefault(i + 6));
}
}
return hash;
}
private static int Combine(params object[] values)
{
unchecked
{
int hash = 17;
foreach (var v in values)
{
int h = v?.GetHashCode() ?? 0;
hash = hash * 31 + h;
}
return hash;
}
}
The strange selection of two prime numbers 17 and factor of 31 is to provide diffusion to avoid
hash collisions and avoid also trouble with objects with
symmetric values (a,b) equaling (b,a) is avoided
using this way of summing the hashes from each property. The
HashCode.Combine allows us to avoid this.
7 — Summary
The article has presented a way to do value equality checks for instances of classes in a generic manner supporting an arbitrary number of public (and private) properties, possibly also including fields (and private fields).
If you want an easy way of adding value equality checks in classes and performance allows using the expression compiled delegates shown here with a little overhead initially, you should be able to consider the code here
for some scenarios.
The Github Repo of mine for this source code contains a lot of tests, so the code is tested.
| What you want | How |
|---|
| Compare public properties |
new GenericEqualityComparer<T>() |
| Also include public fields |
new GenericEqualityComparer<T>(includeFields: true) |
| Also include private properties |
new GenericEqualityComparer<T>(includePrivateProperties: true) |
| Also include private fields |
new GenericEqualityComparer<T>(includePrivateFields: true) |
Use == / != operators |
comparer.For(a) == comparer.For(b) |
| Use with LINQ |
list.Distinct(comparer), list.GroupBy(x => x, comparer) |