Is it possible to conceptually evaluate and compare any objects in C#?

In C#, it is conceptually possible to compare any objects, but the method and meaning of comparison depend on the object types and implemented interfaces.

Typically, the following are used for object comparison:

• The Equals(object obj) method — defined in the base class object. By default, it compares references but can be overridden for value comparison.
• The IComparable interface and the generic IComparable<T> — allow defining an order between objects (e.g., for sorting).
• The == and != operators — can be overloaded for custom types.

If objects do not implement any comparison, the comparison will be by reference (i.e., only equal if they point to the same object).

An example of value comparison implementation:

class Person : IEquatable<Person>, IComparable<Person>
{
    public string Name { get; set; }
    public int Age { get; set; }

    public bool Equals(Person other) => other != null && Name == other.Name && Age == other.Age;

    public override bool Equals(object obj) => Equals(obj as Person);

    public override int GetHashCode() => HashCode.Combine(Name, Age);

    public int CompareTo(Person other)
    {
        if (other == null) return 1;
        int nameComparison = string.Compare(Name, other.Name, StringComparison.Ordinal);
        if (nameComparison != 0) return nameComparison;
        return Age.CompareTo(other.Age);
    }
}

Thus, comparison is conceptually possible, but for correct and meaningful comparison, objects should implement the appropriate methods or interfaces.