Правильно реализовать сравнение двух объектов разного типа, но семантически эквивалентных

Я бы настоятельно рекомендовал не реализовывать IEquatable<string>, потому что особенно при работе с коллекциями, словарями, LINQ и т. д. вы действительно не знаете, когда один из этих методов будет вызван где-то глубоко внутри, что может привести к тонкие баги.

Из-за того, что вам нравится сравнивать два объекта разных типов, простой Comparer<T> также не сработает.

Поэтому либо напишите TypeConverter, который преобразует ваш объект в нужный тип (в ваш случай string) или добавьте метод к вашему объекту, например .ToEquatableString(), и используйте их вывод для сравнения вашего объекта с другой строкой.

Вот пример того, как вы можете получить все элементы, которые соответствуют одному из строк в другой коллекции:

IEnumerable<String> otherElements = new[] {"abc", "def", "ghi" };
IEnumerable<ObjectA> myObjects = GetObjects();

var matchesFound = otherElements.Join( // Take the first collection.
              myObjects, // Take the second collection.
              s => s, // Use the elements in the first collection as key (the string).
              obj => obj.ToEquatableString(),  // Create a string from each object for comparison.
              (s, obj) => obj, // From the matching pairs take simply the objects found.
              StringComparer.OrdinalIgnoreCase); // Use a special string comparer if desired.

Есть много возможностей.

Если вы считаете, что ObjectA является своего рода System.String, вы можете написать определяемое пользователем преобразование (неявное или явное) из ObjectA в System.String, или из System.String в ObjectA, или в обоих направлениях.

Вы также можете перегрузить операторы == и != сигнатурой типа operator ==(ObjectA oa, string s). Помните, что между oa == s и s == oa есть разница.

Любая из этих двух возможностей может привести к путанице. Также было бы запутанно переопределить виртуальный Equals(object) или ввести перегрузку Equals(string). Поэтому я не рекомендую внедрять IEquatable<string>.

Почему бы просто не написать метод с неиспользуемым именем, например public bool EqualsString(string s)? Тогда вам, конечно, придется вызывать этот метод явно, но это приведет к меньшей путанице. Другой идеей было бы использовать конструктор сигнатуры public ObjectA(string s), а затем реализовать «однородное» равенство ObjectA и ObjectA.

ПРИМЕЧАНИЕ. Я не рекомендую это решение для данного конкретного случая, но я часто использовал эту структуру для реализации равенства значений для структур. Трудные компромиссы распространены в нашей области, и ответы на них, сопровождаемые соответствующими предостережениями, кажутся уместными.

Я полагаю, что вы хотите разработать семамтику равенства значений для своего класса таким же образом, как инфраструктура .NET делает это для строкового класса. Как минимум необходимо следующее:

public override bool Equals(object obj) { 
  return (obj is ObjectA) && this == (ObjectA)obj; 
}
bool IEquatable<ObjectA>.Equals(ObjectA rhs) { 
  return this == rhs; 
}
public static bool operator != (ObjectA lhs, ObjectA rhs) { 
  return ! (lhs == rhs); 
}
public static bool operator == (ObjectA lhs, ObjectA rhs) {
  return (lhs.PropertyX == rhs.PropertyX);
}
public override int GetHashCode() { 
  return PropertyX.GetHashCode() 
}

Расширение, чтобы разрешить сравнение значений между ObjectA и строкой:

bool IEquatable<ObjectA>.Equals(string rhs) { 
  return this == rhs; 
}
public static bool operator != (ObjectA lhs, string rhs) { 
  return ! (lhs == rhs); 
}
public static bool operator != (string lhs, ObjectA rhs) { 
  return ! (lhs == rhs); 
}
public static bool operator == (ObjectA lhs, string rhs) {
  return (lhs.PropertyX == rhs);
}
public static bool operator == (string lhs, ObjectA rhs) {
  return (lhs == rhs.PropertyX);
}