web-dev-qa-db-fra.com

Comparaison de types C #: Type.Equals vs operator ==

Resharper suggère de remplacer les éléments suivants:

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

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

À:

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

opérateur ==

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

Égale (Type 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 );

Question
Pourquoi operator == Serait-il recommandé par rapport à Equals( Type o ) lors de la comparaison des types?

c#typescomparison-operators
38
Metro Smurf

Je vous suggère de lire l'excellent quand un type n'est-il pas un type? article de blog de Brad Wilson. Pour résumer: un type d'exécution (représenté par le type interne RuntimeType), géré par le CLR n'est pas toujours le même qu'un Type, qui peut être étendu. Equals vérifiera le type de système sous-jacent , tandis que == vérifiera le type lui-même.

Un exemple simple:

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

La raison est simple: les deux sont fonctionnellement équivalents dans ce cas et ce dernier est plus lisible.

4
Justin Niessner

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

La méthode Equals est juste une méthode virtuelle définie dans System.Object et remplacée par les classes qui choisissent de le faire. L'opérateur == est un opérateur qui peut être surchargé par les classes, mais qui a généralement un comportement d'identité.

Pour les types de référence où == n'a pas été surchargé, il compare si deux références se réfèrent au même objet - ce qui est exactement ce que fait l'implémentation d'Equals dans System.Object.

Les types de valeur ne fournissent pas de surcharge pour == par défaut. Cependant, la plupart des types de valeur fournis par le framework fournissent leur propre surcharge. L'implémentation par défaut d'Equals pour un type de valeur est fournie par ValueType et utilise la réflexion pour effectuer la comparaison, ce qui la rend considérablement plus lente qu'une implémentation spécifique au type ne le serait normalement. Cette implémentation appelle également Equals sur des paires de références dans les deux valeurs comparées.

Cependant, la principale différence entre les deux types de comparaison en utilisation normale (où il est peu probable que vous définissiez très souvent vos propres types de valeur) est le polymorphisme. Les opérateurs sont surchargés, pas surchargés, ce qui signifie qu'à moins que le compilateur sache appeler la version plus spécifique, il appellera simplement la version d'identité.

1
Paul Nikonowicz