CA1815 : Remplacez Equals et l'opérateur égal à dans les types valeurCA1815: Override equals and operator equals on value types

TypeNameTypeName OverrideEqualsAndOperatorEqualsOnValueTypesOverrideEqualsAndOperatorEqualsOnValueTypes
CheckIdCheckId CA1815CA1815
CategoryCategory Microsoft.PerformanceMicrosoft.Performance
Modification avec ruptureBreaking Change Sans ruptureNon-breaking

CauseCause

Un type valeur public ne se substitue pas System.Object.Equals, ou n’implémente pas l’opérateur d’égalité (==).A public value type does not override System.Object.Equals, or does not implement the equality operator (==). Cette règle ne vérifie pas les énumérations.This rule does not check enumerations.

Description de la règleRule Description

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.For value types, the inherited implementation of Equals uses the Reflection library, and compares the contents of all fields. 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.Reflection is computationally expensive, and comparing every field for equality might be unnecessary. Si vous prévoyez que les utilisateurs à comparer ou trier des instances, ou les utilisez en tant que clés de table de hachage, votre type valeur doit implémenter Equals.If you expect users to compare or sort instances, or use them as hash table keys, your value type should implement Equals. Si votre langage de programmation prend en charge la surcharge des opérateurs, vous devez également fournir une implémentation des opérateurs d’égalité et d’inégalité.If your programming language supports operator overloading, you should also provide an implementation of the equality and inequality operators.

Comment corriger les violationsHow to Fix Violations

Pour corriger une violation de cette règle, fournissez une implémentation de Equals.To fix a violation of this rule, provide an implementation of Equals. Si vous pouvez implémenter l’opérateur d’égalité.If you can, implement the equality operator.

Quand supprimer les avertissementsWhen to Suppress Warnings

Il est possible de supprimer un avertissement de cette règle si les instances du type valeur ne seront pas comparées à l’autre sans.It is safe to suppress a warning from this rule if instances of the value type will not be compared to each other.

Exemple de ViolationExample of a Violation

DescriptionDescription

L’exemple suivant montre une structure (type valeur) qui enfreint cette règle.The following example shows a structure (value type) that violates this rule.

CodeCode

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 correctifExample of How to Fix

DescriptionDescription

L’exemple suivant résout la violation précédente en substituant System.ValueType.Equals et en implémentant les opérateurs d’égalité (==, ! =).The following example fixes the previous violation by overriding System.ValueType.Equals and implementing the equality operators (==, !=).

CodeCode

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

CA2224 : Remplacez Equals lors de la surcharge de l’opérateur égalCA2224: Override equals on overloading operator equals

CA2231 : Surchargez l’opérateur égal (equals) en remplaçant ValueType.EqualsCA2231: Overload operator equals on overriding ValueType.Equals

CA2226 : Les opérateurs doivent avoir des surcharges symétriquesCA2226: Operators should have symmetrical overloads

Voir aussiSee Also

System.Object.Equals