== или .Equals ()

== - это проверка личности. Он вернет true, если два тестируемых объекта на самом деле являются одним и тем же объектом. Equals() выполняет проверку на равенство и вернет истину, если два объекта считают себя равными.

Проверка идентичности выполняется быстрее, поэтому ее можно использовать, когда нет необходимости в более дорогостоящих проверках на равенство. Например, сравнение с null или пустой строкой.

Можно перегрузить любой из них, чтобы обеспечить различное поведение - например, тестирование идентичности для Equals() - но ради того, чтобы кто-нибудь читал ваш код, пожалуйста, не делайте этого.

Как указано ниже: некоторые типы, такие как String или DateTime, предоставляют перегрузки для оператора ==, которые придают ему семантику равенства. Таким образом, точное поведение будет зависеть от типов сравниваемых объектов.

Смотрите также:

• http://blogs.msdn.com/csharpfaq/archive/2004/03/29/102224.aspx

используйте equals, если вы хотите выразить, что содержимое сравниваемых объектов должно быть равно. используйте == для примитивных значений или если вы хотите проверить, что сравниваемые объекты являются одним и тем же объектом. Для объектов == проверяет, совпадает ли адресный указатель объектов.

== обычно "идентичность" означает, что "объект a фактически является тем же самым объектом в памяти, что и объект b".

equals () означает, что объекты логически равны (скажем, с точки зрения бизнеса). Поэтому, если вы сравниваете экземпляры определенного пользователем класса, вам обычно нужно использовать и определять equals (), если вы хотите, чтобы такие вещи, как Hashtable, работали правильно.

Если у вас был пресловутый класс Person со свойствами «Имя» и «Адрес», и вы хотели использовать это лицо в качестве ключа к хеш-таблице, содержащей дополнительную информацию о них, вам нужно было бы реализовать equals () (и хэш), чтобы вы может создать экземпляр Person и использовать его в качестве ключа в Hashtable для получения информации.

Используя только ==, ваш новый экземпляр нет будет таким же.

Согласно MSDN:

В C# существует два разных вида равенства: ссылочное равенство (также известное как идентичность) и равенство значений. Равенство значений - это общепринятый смысл равенства: это означает, что два объекта содержат одинаковые значения. Например, два целых числа со значением 2 имеют равенство значений. Ссылочное равенство означает, что нет двух объектов для сравнения. Вместо этого есть две объектные ссылки, и обе относятся к одному и тому же объекту.

...

По умолчанию оператор == проверяет равенство ссылок, определяя, указывают ли две ссылки на один и тот же объект.

Пример состоит в том, что класс DateTime реализует интерфейс IEquatable, который реализует «специфичный для типа метод определения равенства экземпляров». согласно MSDN.

Еще одна вещь, которую следует принять во внимание: оператор == может быть не вызываемым или может иметь другое значение, если вы обращаетесь к объекту с другого языка. Обычно лучше иметь альтернативу, которую можно назвать по имени.

Все остальные в значительной степени вас охватили, но у меня есть еще один совет. Время от времени вы будете встречать кого-то, кто клянется своей жизнью (и жизнями своих близких), что .Equals более эффективен / лучше / лучше всего подходит для некоторых других догматических высказываний. Я не могу говорить об эффективности (ну, хорошо, в определенных обстоятельствах я могу), но я могу поговорить о большой проблеме, которая возникнет: .Equals требует, чтобы объект существовал. (Звучит глупо, но людей это сбивает с толку.)

Вы не можете делать следующее:

StringBuilder sb = null;
if (sb.Equals(null))
{
    // whatever
}

Мне и, возможно, большинству людей кажется очевидным, что вы получите NullReferenceException. Однако сторонники .Equals забывают об этом маленьком факте. Некоторых даже "отбрасывают" (извините, не смог устоять), когда они видят, что NullRefs начинают всплывать.

(За годы до публикации DailyWTF я действительно работал с кем-то, кто уполномоченный, что все проверки равенства выполняются .Equals, а не ==. Даже доказательство его неточности не помогло. Мы просто чертовски постарались нарушить все остальные его правила, чтобы не было никаких ссылок возвращенный из метода, ни свойство никогда не было нулевым, и в конце концов это сработало.)

@ Джон Милликин:

Pointed out below: some value types like DateTime provide overloads for the == operator >that give it equality semantics. So the exact behavior will depend on the types of the >objects you are comparing.

Чтобы уточнить:

DateTime реализован как структура. Все структуры являются дочерними по отношению к System.ValueType.

Поскольку дочерние элементы System.ValueType живут в стеке, ссылочный указатель на кучу отсутствует, и, следовательно, нет возможности выполнить проверку ссылки, вы должны сравнивать объекты только по значению.

System.ValueType переопределяет .Equals () и == для использования проверки равенства на основе отражения, он использует отражение для сравнения значений каждого поля.

Поскольку отражение происходит несколько медленно, если вы реализуете свою собственную структуру, важно переопределить .Equals () и добавить свой собственный код проверки значений, так как это будет намного быстрее. Не вызывайте просто base.Equals ();

Я видел Object.ReferenceEquals (), используемый в тех случаях, когда нужно знать, относятся ли две ссылки к одному и тому же объекту.

И Equals, и == могут быть перегружены, поэтому точные результаты вызова одного или другого будут отличаться. Обратите внимание, что == определяется во время компиляции, поэтому, хотя фактическая реализация может измениться, то, какой == используется, фиксируется во время компиляции, в отличие от Equals, который может использовать другую реализацию в зависимости от типа времени выполнения левой стороны.

Например, string выполняет тест на равенство для ==.

Также обратите внимание, что семантика обоих может быть сложный.

Лучше всего реализовать равенство, как в этом примере. Обратите внимание, что вы можете упростить или исключить все это в зависимости от того, как вы планируете использовать свой класс, и что struct уже получает большую часть этого.

class ClassName
{
    public bool Equals(ClassName other)
    {
        if (other == null)
        {
            return false;
        }
        else
        {
            //Do your equality test here.
        }
    }

    public override bool Equals(object obj)
    {
        ClassName other = obj as null; //Null and non-ClassName objects will both become null
        if (obj == null)
        {
            return false;
        }
        else
        {
            return Equals(other);
        }
    }

    public bool operator ==(ClassName left, ClassName right)
    {
        if (left == null)
        {
            return right == null;
        }
        else
        {
            return left.Equals(right);
        }
    }

    public bool operator !=(ClassName left, ClassName right)
    {
        if (left == null)
        {
            return right != null;
        }
        else
        {
            return !left.Equals(right);
        }
    }

    public override int GetHashCode()
    {
        //Return something useful here, typically all members shifted or XORed together works
    }
}

Если вы дизассемблируете (например, с помощью dotPeek) Object, поэтому

public virtual bool Equals(Object obj)

описанный как:

// Returns a boolean indicating if the passed in object obj is
// Equal to this.  Equality is defined as object equality for reference
// types and bitwise equality for value types using a loader trick to
// replace Equals with EqualsValue for value types). 
//

Итак, это зависит от типа. Например:

        Object o1 = "vvv";
        Object o2 = "vvv";
        bool b = o1.Equals(o2);

        o1 = 555;
        o2 = 555;
        b = o1.Equals(o2);

        o1 = new List<int> { 1, 2, 3 };
        o2 = new List<int> { 1, 2, 3 };
        b = o1.Equals(o2);

Первый раз b является истинным (равное выполняется для типов значений), второй раз b истинно (равно выполняется для типов значений), третий раз b является ложным (равное выполняется для ссылочных типов).

В большинстве случаев они одинаковы, поэтому для ясности следует использовать ==. Согласно рекомендациям по проектированию Microsoft Framework:

«ДЕЛАТЬ гарантирует, что Object.Equals и операторы равенства имеют одинаковую семантику и аналогичные характеристики производительности». https://docs.microsoft.com/en-us/dotnet/standard/design-guidelines/equality-operators

Но иногда кто-то переопределяет Object.Equals без предоставления операторов равенства. В этом случае вы должны использовать Equals для проверки равенства значений и Object.ReferenceEquals для проверки ссылочного равенства.