C# Type De Comparaison: Type.Est égale à vs opérateur ==

Resharper suggère que la suite être modifié à partir de:

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

Equals( 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 == être recommandée au cours de Equals( Type o ) lorsque l'on compare les Types?

InformationsquelleAutor Metro Smurf | 2012-02-10
  1. 36

    Je vous suggère de lire l'excellent quand on est un type de pas type? blog de Brad Wilson. Pour résumer: un runtime type (représenté par le type interne RuntimeType), géré par le CLR n'est pas toujours la même comme un Type, qui peut être prolongée. Equals permettra de vérifier la système sous-jacent de type, alors que == va vérifier 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
    InformationsquelleAutor Julien Lebosquain
  2. 4

    La raison en est simple: Les deux sont fonctionnellement équivalents, dans ce cas, et le dernier est plus lisible.

    • R# généralement de proposer quelque chose et de donner une raison valable; dans ce cas, si ils sont fonctionnellement équivalents, j'ai des doutes que la suggestion soit pour des raisons de lisibilité, ce qui est subjectif. Je me demande si il y a une autre raison, il est suggéré?
    • R# le suggère souvent des choses pour l'amour de la lisibilité (réduction de la nidification dans les instructions if, par exemple).
    • C'est très probablement le but de la raison, mais que les deux ne sont pas fonctionnellement équivalent dans ce cas, alors c'est sûrement une erreur dans Resharper?
    InformationsquelleAutor Justin Niessner
  3. 1

    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 un monde virtuel défini dans le Système.Objet, et
    remplacée par celle des classes choisissez de le faire. L'opérateur == est un
    l'opérateur qui peut être surchargé par les classes, mais qui a d'habitude
    l'identité de comportement.

    Pour les types référence où == n'a pas été surchargé, il compare
    si deux références se rapportent au même objet - ce qui est exactement
    ce que la mise en œuvre d'égal à Égal dans le Système.Objet.

    Types de valeur ne fournissent pas une surcharge pour l' == par défaut. Cependant,
    la plupart des types de valeur fournie par le framework de fournir leurs propres
    la surcharge. La valeur par défaut de la mise en œuvre d'égal à Égal pour un type de valeur est
    fournis par ValueType, et utilise la réflexion pour faire la comparaison,
    ce qui le rend nettement plus lent qu'un type spécifique
    la mise en œuvre serait normalement. Cette mise en œuvre également des appels
    Égal sur des paires de références dans les deux valeurs comparées.

    Cependant, la principale différence entre les deux types de comparaison
    usage normal (où vous avez peu de chances d'être de définir vos propres types de valeur
    très souvent) est le polymorphisme. Les opérateurs sont surchargés, ce n'est pas remplacée,
    ce qui signifie que, à moins que le compilateur sait appeler les plus spécifiques
    version, il vous suffit d'appeler l'identité de la version.

    InformationsquelleAutor Paul Nikonowicz