[Feature Request] Graph comparison to handle objects that expose their data through user-defined conversion instead of fields/properties

Description

Currently, Should().BeEquivalentTo() does not look at private members.

I happen to work in a codebase where most types have been encapsulated in the following fashion:

record PositiveInteger
{
  readonly int _encapsulated;
  PositiveInteger(int encapsulated)
  {
    if (encapsulated <0)
      throw new ObjectIntegrityException("A PositiveInteger cannot encapsulate a negative number.");

    _encapsulated = encapsulated;
  }

  public static PositiveInteger CreateFromInteger(int i)
  {
    return new PositiveInteger(i);
  }

  // how the data is "publicly exposed": passing a PositiveInteger where an int is expected, works!
  public static implicit operator int(PositiveInteger positiveInteger)
  {
    return positiveInteger._encapsulated;
  }
}

As you can see, the int version of the data is “exposed” not through a field or property, but through a user-defined conversion.

However, because the graph does not look at any private member, it will find that PositiveInteger.CreateFromInteger(1) is in fact equivalent to PositiveInteger.CreateFromInteger(2).

It would be cool to have a way to handle this use case.

Simple repository for reproduction : link

On top of my head, an option such as options => options.IncludePrivateFieldsForObjectsWhose[Namespace/FullName]Matches("regex") may be a good candidate.

Versions

• fluentassertions v6.7.0
• dotnet 6

[Melandel]

I managed to make it work.

Leaving this for future readers: custom record collections for native deep equals when using ComparingRecordsByValue (with tests)

[Melandel]

I had to ask ^^

Thank you for your time and answer!

I will see with the other options left. Maybe some kind of custom collection such as

sealed record Values<T> : IEnumerable<T>
{
	readonly T[] _encapsulated;
	Values(IEnumerable<T> encapsulated)
	{
		_encapsulated = encapsulated.ToArray();
	}
	public static Values<T> From(IEnumerable<T> enumerable)                            => new(enumerable ?? Array.Empty<T>());
	public static Values<T> Gather(params T[] array)                                   => new(array);
	public static Values<T> From(T item)                                               => new(new[] { item });
	public static Values<T> SelectFrom<S>(IEnumerable<S> enumerable, Func<S,T> lambda) => new(enumerable?.Select(lambda));

	public IEnumerator<T> GetEnumerator() => ((IEnumerable<T>)_encapsulated).GetEnumerator();
	IEnumerator IEnumerable.GetEnumerator() => _encapsulated.GetEnumerator();
	public bool Equals(Values<T> other) => _encapsulated.SequenceEqual(other ?? new(Array.Empty<T>()));
	public override int GetHashCode()
	{
		return unchecked(this.Aggregate(19, (h, i) => h * 19 + i.GetHashCode()));
	}
}