CA1815: Reemplazar Equals y el operador Equals en los tipos de valor

Artículo
06/08/2015

TypeName	OverrideEqualsAndOperatorEqualsOnValueTypes
Identificador de comprobación	CA1815
Categoría	Microsoft.Performance
Cambio problemático	Poco problemático

Motivo

Un tipo de valor público no reemplaza Object.Equals ni implementa al operador de igualdad (==).Esta regla no comprueba las enumeraciones.

Descripción de la regla

Para los tipos de valor, la implementación heredada de Equals utiliza la biblioteca de reflexiones y compara el contenido de todos los campos.Mediante el cálculo, la reflexión es cara y no es necesario comparar cada campo para comprobar si hay igualdad.Si espera que los usuarios comparen u ordenen las instancias, o las utiliza como claves de tabla hash, el tipo de valor debería implementar Equals.Si su lenguaje de programación admite la sobrecarga de operadores, también debería proporcionar una implementación de la igualdad y operadores de desigualdad.

Cómo corregir infracciones

Para corregir una infracción de esta regla, proporcione una implementación de Equals.Si puede, implemente al operador de igualdad.

Cuándo suprimir advertencias

Es seguro suprimir una advertencia de esta regla si las instancias del tipo de valor no se comparan entre sí.

Ejemplo de infracción

Descripción

En el siguiente ejemplo se muestra una estructura (tipo de valor) que infringe esta regla.

Código

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

Ejemplo de cómo corregir

Descripción

En el ejemplo siguiente se invalida ValueType.Equals y se implementan los operadores de igualdad (==, !=) para corregir la infracción anterior.

Código

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