如何比较两个实现相同接口的不同类是否相等？

Question

public interface IMyType{
    int Val1 {get; set;}
    int Val2 {get; set;}
}


public class ImplA : IMyType{
    public int Val1 {get; set;}
    public int Val2 {get; set;}
    public string Name {get; set;}
    
}

public class ImplB : IMyType{
    public int Val1 {get; set;}
    public int Val2 {get; set;}
    public int Age {get; set;}
    
}

List<IMyType> myTypes = new List<IMyType>();
myTypes.Add(new ImplA(){ Val1 = 100, Val2 = 200, Name ="John"});
myTypes.Add(new ImplA(){ Val1 = 500, Val2 = 600, Name ="Steve"});

IMyType t = new ImplB(){ Val1 = 100, Val2 = 200, Age =30});

bool exists = myTypes.Contains(t); //returns false because types are different

It makes sense that it compares the implementation types for equality and results in 'false' but is there a way to do equality and contains such that it ignores the implementation types and only compares the interface properties for equality? (in this example it would return true since Val1 and Val2 are equal)

Answer 1

If you can't override a custom Equals on your types, you can always define a custom Equality Comparer for the interface type.

using System:
using System.Collections.Generic;

// implements IEqualityComparer<IMyType> 
// it's recommended to derive from EqualityComparer<T>
public class MyTypeComparer : EqualityComparer<IMyType>
{
   public override int GetHashCode(IMyType obj){
      return HashCode.Combine(obj.Val1, obj.Val2);
      // or if System.HashCode is unavailable, something like
      // return 37 ^ obj.Val1 ^ obj.Val2;
   } 
   public override bool Equals(IMyType a, IMyType b) {
      if (ReferenceEquals(a, b)) return true;
      if (a is null || b is null) return false;
      return a.Val1 == b.Val1 && a.Val2 == b.Val2;
   } 
} 

Then use the Enumerable.Contains extension method that accepts an IEqualityComparer<T> rather than List<T>.Contains

using System;
using System.Linq;
using System.Collections.Generic;

var myTypes = new List<IMyType>();
myTypes.Add(new ImplA(){ Val1 = 100, Val2 = 200, Name = "John"});
myTypes.Add(new ImplA(){ Val1 = 500, Val2 = 600, Name = "Steve"});

IMyType t = new ImplB(){ Val1 = 100, Val2 = 200, Age = 30 };
bool exists = myTypes.Contains(t, new MyTypeComparer());

Console.WriteLine(exists); // true

See this SharpLab for an example.

Answer 2

returns false because types are different

No, it returns false because it's a new instance. Test this with the following:

myTypes.Add(new ImplA(){ Val1 = 100, Val2 = 200, Name ="John"});
bool exists = myTypes.Contains(new ImplA(){ Val1 = 100, Val2 = 200, Name ="John"});

That will still return false as written.

Why is that? Because you didn't override the default object.Equals(object) virtual method in either of your types, and the default implementation calls object.ReferenceEquals , which returns whether the two objects have the same reference, ie if they're literally the same instance.

From what I understand, you want to override object.Equals like this:

public class ImplA : IMyType
{
    public int Val1 {get; set;}
    public int Val2 {get; set;}
    public string Name {get; set;}

    public override bool Equals(object obj) =>
        obj is ImplA objA ? (Val1, Val2, Name) == (objA.Val1, objA.Val2, objA.Name)
        : obj is IMyType objI ? (Val1, Val2) == (objI.Val1, objI.Val2)
        : false;
}

Answer 3

I fully support Blindy's answer for the corrections to the misapprehensions about how objects are compared (by memory address, absent any override of Equals/GetHashCode) it makes, and it's how I would have proposed working.

You said in a comment that you cannot override Equals for ImplX / IMyType, which is surprising but if it's a constraint that must be suffered then you can alter the way you check for whether the list contains a matching item:

is there a way to do equality and contains such that it ignores the implementation types and only compares the interface properties for equality? (in this example it would return true since Val1 and Val2 are equal)

It depends what you mean by "contains". If you mean exactly and specifically using Contains(T) , without being able to override Equals for the items, then No unless you want to extend the list and override Contains instead.. But LINQ's Any(=>) can tell you if a list contains an item, and because it's all IMyType regardless of the actual implementation, you can do this:

IMyType t = new ImplB(){ Val1 = 100, Val2 = 200, Age =30});
bool exists = myTypes.Any(i => i.Val1 == t.Val1 && i.Val2 == t.Val2);

You could bake this into an inherited list as an override to Contains too, if you like..

Answer 4

yes. You can use Reflection. There are better methods that this but you can take it as sample.

    public static bool Compare(IMyType a, IMyType b)
    {
        IList<PropertyInfo> properties = typeof(IMyType).GetProperties().ToList();
        bool risposta = true;
        foreach (var property in properties)
        {
            if (!property.GetValue(a).Equals(property.GetValue(b)))
            {
                risposta = false;
            }
        }
        return risposta;
    }

Use this method for check if object are in list.

public static bool CheckIfExists(List<IMyType> list, IMyType newObj) {
        foreach (IMyType m in list) {
            if(Compare(m, newObj))
            {
                return true;
            }
        }
        return false;
    }

And add in List:

if (!CheckIfExists(myTypes, t)) {
            myTypes.Add(t);
        }