Можно ли сравнить любые объекты в C#?

А, ну это же про сравнение объектов в C#! Ну, тут, блядь, целая наука, если честно. Не то чтобы сложная, но нюансов — овердохуища.

Смотри, есть три основных способа сравнить что угодно:

1. Операторы == и != — самые очевидные.
2. Метод object.Equals() — классика жанра.
3. object.ReferenceEquals() — когда нужно докопаться до самой сути, до ссылок.

А теперь самое интересное — как это всё работает на самом деле. Всё зависит от того, с чем ты имеешь дело.

1. Классы (ссылочные типы) Вот тут, сука, подстава. По умолчанию, если ты не переопределил методы, и ==, и Equals() сравнивают не то, что внутри объекта, а ссылки на него в памяти. То есть, одно и то же место или нет.

class Person { public string Name; }

var person1 = new Person { Name = "Alice" };
var person2 = new Person { Name = "Alice" }; // Два разных объекта, в памяти лежат в разных местах
var person3 = person1; // А это просто новая переменная, которая указывает на ТОТ ЖЕ САМЫЙ объект, что и person1

Console.WriteLine(person1 == person2);     // False (разные адреса в памяти, разные ссылки)
Console.WriteLine(person1.Equals(person2)); // False (опять же, разные ссылки, нихуя не равны)
Console.WriteLine(person1 == person3);     // True (ну это одна и та же хуйня, одна ссылка)

Получается, что два человека с одинаковым именем — не равны. Логика? Её тут нет. Если хочешь сравнивать по смыслу (по значениям полей), то придётся, блядь, попотеть: переопределять Equals(), GetHashCode() и, возможно, операторы ==/!=.

2. Структуры (значимые типы) Со структурами другая песня. Метод Equals() по умолчанию тупо сравнивает значения всех полей (правда, делает это через рефлексию, то есть медленно и печально). А вот оператор == для структур по умолчанию вообще не работает, компилятор ругнётся.

public struct Point { public int X, Y; }

var p1 = new Point { X = 1, Y = 2 };
var p2 = new Point { X = 1, Y = 2 };

Console.WriteLine(p1.Equals(p2)); // True (значения всех полей одинаковые, значит, равны)
// Console.WriteLine(p1 == p2);   // Ошибка компиляции, ёпта! Оператор == не определён, иди нахуй.

Что делать, если хочешь сравнивать свои объекты правильно? Вот тебе, блядь, выжимка, как не облажаться:

• Реализуй интерфейс IEquatable<T>. Это даст тебе типобезопасный и быстрый метод Equals(T other). Без этого — одни танцы с приведением типов.
• GetHashCode() — твой кровавый договор. Если переопределил Equals(), то и хэш-код переопредели обязательно, чтобы они были согласованы. Иначе все коллекции (типа Dictionary) просто ебнут тебе мозг.
• Для классов можешь перегрузить операторы == и !=. Чтобы красивше было.
• ReferenceEquals() — это когда тебе похуй на содержимое, а важно, один ли это объект в памяти. Явная и честная проверка.

Вот, смотри, как примерно это делают не ленивые:

public class Product : IEquatable<Product>
{
    public int Id { get; set; }
    public string Name { get; set; }

    // Самый главный метод, который всё и решает
    public bool Equals(Product other)
    {
        if (other is null) return false; // если нам подсунули null, то какой нахуй equals
        return Id == other.Id && Name == other.Name; // сравниваем по бизнес-логике
    }

    // Старая добрая перегрузка от object
    public override bool Equals(object obj) => Equals(obj as Product);

    // Хэш-код, блядь! Без него нихуя не получится.
    public override int GetHashCode() => HashCode.Combine(Id, Name);
}

Вот и вся магия. Главное — понимать, что сравниваешь и зачем. А то можно так наебнуться с этими сравнениями, что потом полгода дебажить.