Nullable<int> est-il un "type de valeur prédéfini" - Ou comment fonctionne Equals() et == ici ?

Question

Pour ma propre mise en œuvre d'une méthode Equals(), je veux vérifier un certain nombre de champs internes. Je le fais comme ceci :

...
_myNullableInt == obj._myNullableInt &&
_myString == obj._myString &&
...

Je suppose que cette opération compare les valeurs, y compris les nullités, pour l'égalité et non l'adresse de l'objet (comme le ferait une opération de comparaison d'euqalité de référence) parce que :

Il est dit ainsi pour les "types de valeurs prédéfinies". dans ce document MSDN ici . Je suppose Nullable<int> est un tel "type de valeur prédéfini" parce qu'il se trouve dans la base de données de l'UE. System Espace de nom selon ce document MSDN .

Ai-je raison de supposer que les VALEURS sont comparées ici ?

Note : Les tests unitaires ont montré "Oui", mais je voulais être rassuré par d'autres personnes avec cette question, juste au cas où j'aurais manqué quelque chose.

Answer 1

En C#, il existe un concept appelé "Lifted Operators", décrit dans la section 7.3.7 de la spécification du langage ( Téléchargement de la version 5 ) :

Les opérateurs soulevés permettent aux opérateurs prédéfinis et définis par l'utilisateur qui opèrent sur des types de valeurs non annulables d'être également utilisés avec des formes annulables de ces types. Les opérateurs élevés sont construits à partir d'opérateurs prédéfinis et définis par l'utilisateur qui répondent à certaines exigences, comme décrit ci-après.

Et plus précisément :

Pour les opérateurs d'égalité

==  !=

une forme levée d'un opérateur existe si les types d'opérandes sont tous deux des types de valeurs non nulles et si le type de résultat est bool. La forme levée est construite en ajoutant un seul modificateur ? à chaque type d'opérande. L'opérateur levé considère que deux valeurs nulles sont égales, et qu'une valeur nulle n'est pas égale à une valeur non nulle. Si les deux opérandes sont non nuls, l'opérateur levé déballe les opérandes et applique l'opérateur sous-jacent pour produire le résultat bool.

Donc, puisqu'il y a un == opérateur défini entre int il y en a aussi un défini pour les int? s

Answer 2

Si vous comparez ces valeurs, il appellera en fait la fonction Nullable<T>.Equals puisque les deux valeurs sont des ints nullables.

Nullable<T>.Equals finira par appeler le == compare le mot clé de int, si les deux valeurs ne sont pas nulles. Donc, à la fin, il vérifiera effectivement les valeurs.

Le code de la Equals le montre bien :

public override bool Equals(object other)
{
    if (!this.HasValue)
    {
        return (other == null);
    }
    if (other == null)
    {
        return false;
    }
    return this.value.Equals(other);
}