CA2218 : Remplacez GetHashCode au moment de remplacer Equals

Élément	Valeur
ID de la règle	CA2218
Category	Microsoft.Usage
Modification avec rupture	Sans rupture

Cause

Un type public se substitue à System.Object.Equals, mais pas à System.Object.GetHashCode.

Description de la règle

GetHashCode retourne une valeur fondée sur l’instance actuelle, adaptée aux algorithmes de hachage et aux structures de données telles qu’une table de hachage. Deux objets de même type et égaux doivent retourner le même code de hachage pour garantir que les instances des types suivants fonctionnent correctement :

• System.Collections.Hashtable

• System.Collections.SortedList

• System.Collections.Generic.Dictionary<TKey,TValue>

• System.Collections.Generic.SortedDictionary<TKey,TValue>

• System.Collections.Generic.SortedList<TKey,TValue>

• System.Collections.Specialized.HybridDictionary

• System.Collections.Specialized.ListDictionary

• System.Collections.Specialized.OrderedDictionary

• Types qui implémentent System.Collections.Generic.IEqualityComparer<T>

Comment corriger les violations

Pour corriger une violation de cette règle, fournissez une implémentation de GetHashCode. Pour une paire d’objets du même type, vous devez veiller à ce que l’implémentation retourne la même valeur si votre implémentation de Equals retourne true pour la paire.

Quand supprimer les avertissements

Ne supprimez aucun avertissement de cette règle.

Exemple de classe

Description

L’exemple suivant montre une classe (type référence) qui enfreint cette règle.

Code

using System; 

namespace Samples
{    
    // Violates this rule    
    public class 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 bool Equals(object obj)        
        {            
            if (obj == null)                
                return false;             
            
            if (GetType() != obj.GetType())                
                return false;             
                
            Point point = (Point)obj;             
            
            if (_X != point.X)                
                return false;             
                
            return _Y == point.Y;        
        }    
    }
}

Commentaires

L’exemple suivant corrige la violation en remplaçant GetHashCode().

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

Exemple de structure

Description

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

Code

using System; 

namespace Samples
{    
    // Violates this rule    
    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 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);        
        }    
    }
}

Commentaires

L’exemple suivant corrige la violation en remplaçant GetHashCode().

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

Règles associées

CA1046 : Ne pas surcharger l'opérateur égal à sur les types référence

CA2225 : Les surcharges d'opérateur offrent d'autres méthodes nommées

CA2226 : Les opérateurs doivent contenir des surcharges symétriques

CA2224 : Remplacez Equals au moment de surcharger l'opérateur égal

CA2231 : Surchargez l’opérateur égal (equals) en remplaçant ValueType.Equals

Voir aussi

• System.Object.Equals
• System.Object.GetHashCode
• System.Collections.Hashtable
• Opérateurs d'égalité