Сравнение типов С#: Type.Equals vs operator ==

Resharper предлагает изменить следующее:

Type foo = typeof( Foo );
Type bar = typeof( Bar );

if( foo.Equals( bar ) ) { ... }

To:

if( foo == bar ) { ... }

оператор ==

// Summary:
//     Indicates whether two System.Type objects are equal.
//
// Parameters:
//   left:
//     The first object to compare.
//
//   right:
//     The second object to compare.
//
// Returns:
//     true if left is equal to right; otherwise, false.
public static bool operator ==( Type left, Type right );

Равные (Тип o)

// Summary:
//     Determines if the underlying system type of the current System.Type is the
//     same as the underlying system type of the specified System.Type.
//
// Parameters:
//   o:
//     The System.Type whose underlying system type is to be compared with the underlying
//     system type of the current System.Type.
//
// Returns:
//     true if the underlying system type of o is the same as the underlying system
//     type of the current System.Type; otherwise, false.
public virtual bool Equals( Type o );

Вопрос
Почему рекомендуется operator == по сравнению с Equals( Type o ) при сравнении типов?

Ответы

Ответ 1

Я предлагаю вам прочитать отличный когда это тип не типа? в блоге Брэда Уилсона. Подводя итог: тип времени выполнения (представленный внутренним типом RuntimeType), управляемый CLR, не всегда совпадает с Type, который может быть расширен. Equals проверит базовый тип системы, тогда как == проверит сам тип.

Простой пример:

Type type = new TypeDelegator(typeof(int));
Console.WriteLine(type.Equals(typeof(int))); // Prints True
Console.WriteLine(type == typeof(int));      // Prints False

Ответ 2

Причина проста: они функционально эквивалентны в этом случае, а последние более читабельны.

Ответ 3

Из http://blogs.msdn.com/b/csharpfaq/archive/2004/03/29/when-should-i-use-and-when-should-i-use-equals.aspx

Метод Equals является только виртуальным, определенным в System.Object, и переопределяется тем, какие классы предпочитают делать это. Оператор == является оператора, который может быть перегружен классами, но обычно идентичность.

Для ссылочных типов, где == не было перегружено, оно сравнивает ссылаются ли две ссылки на один и тот же объект - что точно какова реализация Equals в System.Object.

Типы значений не обеспечивают перегрузку для == по умолчанию. Однако, большинство типов значений, предоставляемых каркасом, предоставляют свои собственные перегрузки. Стандартная реализация Equals для типа значения предоставляемый ValueType, и использует отражение для сравнения, что делает его значительно медленнее, чем тип осуществление обычно было бы. Эта реализация также вызывает Равен на пары ссылок в двух сравниваемых значениях.

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