diferente - Comparación de tipo C#: Type.Equals vs operator==

string diferente de c#

Question

Resharper sugiere que se cambie lo siguiente de:

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

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

A:

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

operador ==

// 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 );

Igual (Tipo 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 );

Pregunta
¿Por qué el operator == se recomienda sobre Equals( Type o ) al comparar Tipos?

Answer 1

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

El método Equals es solo uno virtual definido en System.Object, y es anulado por cualquiera de las clases que elijan hacerlo. El operador == es un operador que puede estar sobrecargado por clases, pero que generalmente tiene un comportamiento de identidad.

Para los tipos de referencia donde == no se ha sobrecargado, compara si dos referencias se refieren al mismo objeto, que es exactamente lo que hace la implementación de Equals en System.Object.

Los tipos de valor no proporcionan una sobrecarga para == de manera predeterminada. Sin embargo, la mayoría de los tipos de valores proporcionados por el marco proporcionan su propia sobrecarga. La implementación predeterminada de Igual para un tipo de valor es provista por ValueType, y utiliza la reflexión para hacer la comparación, lo que la hace significativamente más lenta que lo que normalmente sería una implementación de tipo específico. Esta implementación también llama a Equals en pares de referencias dentro de los dos valores que se comparan.

Sin embargo, la diferencia principal entre los dos tipos de comparación en el uso normal (donde es poco probable que defina sus propios tipos de valores muy a menudo) es el polimorfismo. Los operadores están sobrecargados, no anulados, lo que significa que a menos que el compilador sepa llamar a la versión más específica, simplemente llamará a la versión de identidad.

Answer 2

La razón es simple: los dos son funcionalmente equivalentes en este caso y el último es más legible.

Answer 3

Le sugiero que lea el excelente cuando es un tipo no es un tipo? publicación de blog de Brad Wilson. En resumen: un tipo de tiempo de ejecución (representado por el tipo interno RuntimeType), administrado por el CLR, no siempre es lo mismo que un Type , que puede ampliarse. Equals comprobará el tipo de sistema subyacente , mientras que == comprobará el tipo en sí.

Un simple ejemplo:

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