CA1815: Eseguire l'override di Equals e dell'operatore "uguale a" sui tipi di valore

Articolo
03/05/2013

TypeName	OverrideEqualsAndOperatorEqualsOnValueTypes
CheckId	CA1815
Category	Microsoft.Performance
Breaking Change	Non sostanziale

Causa

Un tipo di valore pubblico non esegue l'override di Object.Equals o non implementa l'operatore di uguaglianza (==).Questa regola non richiede il controllo delle enumerazioni.

Descrizione della regola

Per i tipi di valore, l'implementazione ereditata di Equals utilizza la libreria Reflection e confronta il contenuto di tutti i campi.La libreria Reflection è onerosa dal punto di vista del calcolo, inoltre il confronto di ogni campo per determinarne l'uguaglianza potrebbe essere superfluo.Se si prevede che gli utenti confrontino o ordinino le istanze oppure le utilizzino come chiavi di tabelle hash, il tipo di valore deve implementare Equals.Se il linguaggio di programmazione in uso supporta l'overload dell'operatore, è necessario fornire un'implementazione degli operatori di uguaglianza e disuguaglianza.

Come correggere le violazioni

Per correggere una violazione di questa regola, fornire un'implementazione di Equals.Se possibile, implementare l'operatore di uguaglianza.

Esclusione di avvisi

L'esclusione di un avviso da questa regola è sicura se le istanze del tipo di valore non verranno confrontate tra loro.

Esempio di una violazione

Descrizione

Nell'esempio riportato di seguito viene mostrata una struttura (tipo di valore) che viola questa regola.

Codice

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

Esempio di correzione

Descrizione

Nell'esempio seguente viene corretta la violazione precedente eseguendo l'override di ValueType.Equals e implementando gli operatori di uguaglianza (==! =).

Codice

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