A method for value equality regardless of reference equality

[LupusInferni315]

Object would benefit from containing a method to check for value equality regardless of whether or not a type is a value type or a reference type. I've written an idea as to how this could be implemented. The reason I think this could be useful, is that there are cases where creating a class over a struct is necessary (or in cases where you didn't write the classes being checked for equality) and don't need to know whether or not they are the same instance, and only whether the states are the same. Take a Bitmap class, ValueEquals would return true even if the classes were initialized separately, if the data it contains is the same (ie. all pixels match up.)

public static bool ValueEquals ( this object obj, object other )
{
    if ( obj.GetType () != other.GetType () )
    {
        return false;
    }
    else if ( obj.GetType ().IsValueType )
    {
        return obj.Equals ( other );
    }
    else if ( ReferenceEquals ( obj, other ) )
    {
        return true;
    }
    foreach ( FieldInfo info in obj.GetType ().GetFields ( BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance ) )
    {
        if ( info.FieldType.IsValueType )
        {
            if ( !info.GetValue ( obj ).Equals ( info.GetValue ( other ) ) )
            {
                return false;
            }
        }
        else
        {
            if ( !info.GetValue ( obj ).ValueEquals ( info.GetValue ( other ) ) )
            {
                return false;
            }
        }
    }
    return true;
}

[CyrusNajmabadi]

This appears to be an api request. moving to dotnet/runtime. That said, it looks like you have your solution, so i'm not sure what need there would be for an actual runtime method for this :)

[LupusInferni315]

Since htere's no right way to do it, it's better to just specify what you want and do that in your own code, instead of expecting it from all types.

I will however point out that if provided as an optional implementation (ie. virtual method) you could (at least in a class you write) provide specific implementation when required.

[Joe4evr]

I will however point out that if provided as an optional implementation (ie. virtual method) you could (at least in a class you write) provide specific implementation when required.

This already exists: object.Equals(object).

[LupusInferni315]

object.Equals(object) for classes (by default if not overridden) checks for reference equality, what I was suggesting there would be similar to it, but would always default to value equality, regardless of whether the type is a reference or a value type.

[CyrusNajmabadi]

default to value equality

The main problem, as i mentioned above, is that there is no agreement on what "value equality" means. Field-based equality is definitely not appropriate for many cases. And it's definitely not appropriate to say that all types are value-equatable. Many times absolutely shoudl not ever have these semantics.

[CyrusNajmabadi]

@lupuncture if you want this, you can have this by having your own IEqualityComparer impl that implements exactly these semantics you want for your domain.

[CyrusNajmabadi]

I think "value equality" would have to be very thoroughly defined. WHat is value-equality in the presence of cycles? What is it for arrays? If you have things like dictionaries/sets, what is it in terms of ordering of elements? etc. etc. etc.

I have a feeling the only suitable approach here is for certain types to opt into stating they are value equatable and defining themselves what that means.

[LupusInferni315]

If I understand the idea, it would be a virtual method similar to Equals?

[theunrepentantgeek]

Types can already implement this by implementing IEquatable<T> and defining exactly the semantics that are appropriate for that particular type.

Two instances with identical fields may not actually be equal.

For example:

public class ReferenceCount
{
    public ReferenceCount(int initialValue) ...
    public int Count {get; private set; }
    public void Increment() ...
}

Two instances of ReferenceCount aren't equal even if they contain the same count because they will be counting the references of a different thing.

Any general purpose definition for equality can only ever be mostly correct because there will always be edge cases like this.

[TonyValenti]

Don't records handle most of this automatically for you?

[LupusInferni315]

Types can already implement this by implementing IEquatable

I am aware that, that is at least partially what IEquatable is for, however you can't guarantee that any given class implements it, my suggestion was for a default every object can define its own, or rely on a default implementation of ValueEquals.