PropertiesComparer 32 Property Limit Error Message

[Cincidial]

When using .UsingPropertiesComparer() on a class with 32 or more properties the following error message is returned

System.NotSupportedException : No comparer found for instances of type 'x' and 'x'

(x is the same class in this case, just as an example)

This message doesn't actually tell the test writer what's going on as unless you look at the PropertiesComparer.cs in this repo there's no documentation on a max property limit. At least as far as I could find on this page

As can be seen in the file this check could return it's own enum result for a better error message.

Also, I'm wondering why there is a 32 property max (actually only 31 because a >= is used instead of a >)?
I see in that code there's an int whose 31 of 32 bits are being used as flags, but would that also work as a long so that a max of 64 properties is available instead? A list could also be used instead of bitwise operations so that there is no property limit

[stevenaw]

I'm wondering why there is a 32 property max

A simple answer I could suppose here is just that it was a good starting point 🙂 You are right we could double the number of supported properties just by changing the uint to ulong.

@manfred-brands I know this was a major contribution of yours recently so I'm curious your thoughts on a finite limit here rather than suggesting my own outright. My thinking is there is probably a complexity and slight performance impact if we go beyond 64, but otherwise potentially no issues. Still, it's a trade-off we'd need to consider. A BitArray or a Span<int> could perhaps be used if we wanted to support a boundless amount.

@Cincidial would you be interested in contributing a change here if/once we decide what one could look like?

[Cincidial]

Yup I can do the change if/once y'all decide on the direction you want to take (if that direction is to make a change).

[manfred-brands]

@stevenaw I needed this initially for my company's DataTransferObject developments and we never had any classes with more than 31 properties. I would say not even more than 10. We would aggregate classes hierarchical instead.

So why an 'int'? as that is the default I use for bit masks.
Why the bit mask in the first place it to cope with comparers that cannot use Tolerance.

@Cincidial you have valid points.

The Comparer should throw the exception itself, saying it cannot deal with more than 31 properties.
As it is explicitly specified by the user now we can do this. Initially it was automatic and it would move to the next EqualityComparer in the list. But that limitation will go away with the proposed changes.

I think BitArray is the way to go. We know the size upfront and the BitArray code looks efficient. Although it threw me that they did '1 << index' where index can be greater than 32. Trying it out I was surprised that 1 << 129 actually returns 2. It looks like the shift is converted to 129 & 31.

[stevenaw]

Thanks @manfred-brands !

[Cincidial]

@stevenaw Just to confirm, I'm assuming that this means BitArray has been decided on the approach to take, and I can start on the changes?

Also @manfred-brands, if you want to do the change I don't want to step on your toes as it was your feature addition - I don't mind picking up the work though.

[manfred-brands]

@Cincidial We always welcome contributors.

[stevenaw]

@Cincidial Absolutely, feel free to begin. Please let us know if you had any questions.