Remplacez Equals et l'opérateur égal (equals) dans les types valeur

Article
08/21/2008

Mise à jour : novembre 2007

TypeName	OverrideEqualsAndOperatorEqualsOnValueTypes
CheckId	CA1815
Catégorie	Microsoft.Performance
Modification avec rupture	Modification sans rupture

Cause

Un type valeur public ne se substitue pas à Object.Equals, ni n'implémente l'opérateur d'égalité (==). Cette règle ne vérifie aucune énumération.

Description de la règle

Pour les types valeur, l'implémentation héritée de Equals utilise la bibliothèque Reflection et compare le contenu de tous les champs. Le processus de réflexion sollicite fortement les ressources informatiques et la comparaison de chaque champ à la recherche d'une égalité peut s'avérer inutile. Si des utilisateurs sont susceptibles de comparer ou de trier des instances, ou de les utiliser en tant que clés de table de hachage, votre type valeur doit implémenter Equals. Si votre langage de programmation prend en charge la surcharge d'opérateur, vous devez également fournir une implémentation des opérateurs d'égalité et d'inégalité.

Comment corriger les violations

Pour résoudre une violation de cette règle, fournissez une implémentation d' Equals. Dans la mesure du possible, implémentez l'opérateur d'égalité.

Quand supprimer les avertissements

ll est possible de supprimer sans risque un avertissement de cette règle en l'absence de comparaison des instances du type valeur.

Exemple de violation

Description

L'exemple suivant indique une structure (type valeur) qui enfreint cette règle.

Code

using System; 

namespace Samples
{    
    // Violates this rule    
    public struct Point    
    {        
        private readonly int _X;        
        private readonly int _Y;         

        public Point(int x, int y)        
        {            
            _X = x;            
            _Y = y;        
        }         

        public int X        
        {            
            get { return _X; }        
        }         

        public int Y        
        {            
            get { return _Y; }        
        }    
    }
}

Exemple de résolution

Description

L'exemple suivant résout la violation précédente en remplaçant ValueTypeEquals() et en implémentant les opérateurs d'égalité (==, !=).

Code

using System; 

namespace Samples
{    
    public struct Point : IEquatable<Point>    
    {        
        private readonly int _X;        
        private readonly int _Y;         

        public Point(int x, int y)        
        {            
            _X = x;            
            _Y = y;        
        }         

        public int X        
        {            
            get { return _X; }        
        }         

        public int Y        
        {            
            get { return _Y; }        
        }         

        public override int GetHashCode()        
        {            
            return _X ^ _Y;        
        }         

        public override bool Equals(object obj)        
        {            
            if (!(obj is Point))                
                return false;             

            return Equals((Point)obj);        
        }         

        public bool Equals(Point other)        
        {            
            if (_X != other._X)                
                return false;             

            return _Y == other._Y;        
        }         

        public static bool operator ==(Point point1, Point point2)        
        {            
            return point1.Equals(point2);        
        }         

        public static bool operator !=(Point point1, Point point2)        
        {            
            return !point1.Equals(point2);        
        }    
    }
}