Upgrade your Internet Experience
Microsoft.com
Welcome Sign in
.NET Framework Developer Center
Click to Rate and Give Feedback
MSDN
MSDN Library
.NET Development
Previous Versions
.NET Framework 3.0
Tools
Development Tools
FxCop
FxCop Warnings
Usage Warnings
 Override equals on overloading oper...
Collapse All/Expand All Collapse All
This page is specific to
Microsoft Visual Studio 2005/.NET Framework 2.0

Other versions are also available for the following:
Visual Studio Team System
Override equals on overloading operator equals

TypeName

OverrideEqualsOnOverloadingOperatorEquals

CheckId

CA2224

Category

Microsoft.Usage

Breaking Change

NonBreaking
 Cause

A public type implements the equality operator, but does not override System.Object.Equals.
 Rule Description

The equality operator is intended to be a syntactically convenient way of accessing the functionality of the Equals method. If you implement the equality operator, its logic must be identical to that of Equals.

The C# compiler issues a warning if your code violates this rule.
 How to Fix Violations

To fix a violation of this rule, you should either remove the implementation of the equality operator, or override Equals and have the two methods return the same values. If the equality operator does not introduce inconsistent behavior, you can fix the violation by providing an implementation of Equals that calls the Equals method in the base class.
 When to Exclude Warnings

It is safe to exclude a warning from this rule if the equality operator returns the same value as the inherited implementation of Equals. The Example section includes a type that could safely exclude a warning from this rule.
 Example

The following example shows a type with inconsistent definitions of equality. BadPoint changes the meaning of equality by providing a custom implementation of the equality operator, but does not override Equals so that it behaves identically.

C# 
using System;

namespace UsageLibrary
{   
    public class BadPoint
    {
        private int x,y, id;
        private static int NextId;
        
        static BadPoint()
        {
            NextId = -1;
        }
        public BadPoint(int x, int y)
        {
            this.x = x;
            this.y = y;
            id = ++(BadPoint.NextId); 
        }
        
        public override string ToString()
        {
            return String.Format("([{0}] {1},{2})",id,x,y);
        }
        
        public int X {get {return x;}}
        
        public int Y {get {return x;}}
        public int Id {get {return id;}}
        
        public override int GetHashCode()
        {
            return id;
        }
        // Violates rule: OverrideEqualsOnOverridingOperatorEquals.
        
        // BadPoint redefines the equality operator to ignore the id value.
        // This is different from how the inherited implementation of 
        // System.Object.Equals behaves for value types. 
        // It is not safe to exclude the violation for this type. 
        public static bool operator== (BadPoint p1, BadPoint p2)
        {
            return ((p1.x == p2.x) && (p1.y == p2.y));
        }
        // The C# compiler and rule OperatorsShouldHaveSymmetricalOverloads require this.
        public static bool operator!= (BadPoint p1, BadPoint p2)
        {
            return !(p1 == p2);
        }
    }
}

The following code tests the behavior of BadPoint.

C# 
using System;

namespace UsageLibrary
{   
    public class TestBadPoint
    {
        public static void Main()
        {
            BadPoint a = new BadPoint(1,1);
            BadPoint b = new BadPoint(2,2);
            BadPoint a1 = a;
            BadPoint bcopy = new BadPoint(2,2);
            
            Console.WriteLine("a =  {0} and b = {1} are equal? {2}", a, b, a.Equals(b)? "Yes":"No");
            Console.WriteLine("a == b ? {0}", a == b ? "Yes":"No");
            Console.WriteLine("a1 and a are equal? {0}", a1.Equals(a)? "Yes":"No");
            Console.WriteLine("a1 == a ? {0}", a1 == a ? "Yes":"No");
            
            // This test demonstrates the inconsistent behavior of == and Object.Equals.
            Console.WriteLine("b and bcopy are equal ? {0}", bcopy.Equals(b)? "Yes":"No");
            Console.WriteLine("b == bcopy ? {0}", b == bcopy ? "Yes":"No");
        }
    }
}

This example produces the following output.

Output

a =  ([0] 1,1) and b = ([1] 2,2) are equal? No
a == b ? No
a1 and a are equal? Yes
a1 == a ? Yes
b and bcopy are equal ? No
b == bcopy ? Yes

The following example shows a type that technically violates this rule, but does not behave in an inconsistent manner.

C# 
using System;

namespace UsageLibrary
{
    public struct GoodPoint
    {
        private int x,y;
        
        public GoodPoint(int x, int y)
        {
            this.x = x;
            this.y = y;
        }
        
        public override string ToString()
        {
            return String.Format("({0},{1})",x,y);
        }
        
        public int X {get {return x;}}
        
        public int Y {get {return x;}}
        
        // Violates rule: OverrideEqualsOnOverridingOperatorEquals,
        // but does not change the meaning of equality;
        //  the violation can be excluded.
        
        public static bool operator== (GoodPoint px, GoodPoint py)
        {
            return px.Equals(py);
        }
        
        // The C# compiler and rule OperatorsShouldHaveSymmetricalOverloads require this.
        public static bool operator!= (GoodPoint px, GoodPoint py)
        {
            return !(px.Equals(py));
        }
    }
}

The following code tests the behavior of GoodPoint.

C# 
using System;

namespace UsageLibrary
{ 
    public class TestGoodPoint
    {
        public static void Main()
        {
            GoodPoint a = new GoodPoint(1,1);
            GoodPoint b = new GoodPoint(2,2);
            GoodPoint a1 = a;
            GoodPoint bcopy = new GoodPoint(2,2);
            
            Console.WriteLine("a =  {0} and b = {1} are equal? {2}", a, b, a.Equals(b)? "Yes":"No");
            Console.WriteLine("a == b ? {0}", a == b ? "Yes":"No");
            Console.WriteLine("a1 and a are equal? {0}", a1.Equals(a)? "Yes":"No");
            Console.WriteLine("a1 == a ? {0}", a1 == a ? "Yes":"No");
            
            // This test demonstrates the consistent behavior of == and Object.Equals.
            Console.WriteLine("b and bcopy are equal ? {0}", bcopy.Equals(b)? "Yes":"No");
            Console.WriteLine("b == bcopy ? {0}", b == bcopy ? "Yes":"No");
        }
    }
}

This example produces the following output.

Output

a =  (1,1) and b = (2,2) are equal? No
a == b ? No
a1 and a are equal? Yes
a1 == a ? Yes
b and bcopy are equal ? Yes
b == bcopy ? Yes

The following example shows a class (reference type) that violates this rule.

The following example fixes the above violation by overriding Object.Equals.

The following example shows a structure (value type) that violates this rule.

The following example fixes this violation by overriding ValueType.Equals.
 Related Rules

Do not overload operator equals on reference types

Operator overloads have named alternates

Operators should have symmetrical overloads

Override GetHashCode on overriding Equals

Overload operator equals on overriding value type equals

Tags What's this?: Add a tag
Community Content   What is Community Content?
Add new content RSS  Annotations
Example using a class      David M. Kean - MSFT   |   Edit   |   Show History

The following example shows a class (reference type) that violates this rule.

[C#]
 
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 int GetHashCode()
        {
            return _X ^ _Y;
        }    
 
        public static bool operator ==(Point point1, Point point2)
        {
            // Need to call through ReferenceEquals, to prevent recursion
            if (object.ReferenceEquals(point1, null))
                return object.ReferenceEquals(point2, null);
 
            if (point1.GetType() != point2.GetType())
                return false;
 
            if (point1._X != point2._X)
                return false;
 
            return point1._Y == point2._Y;
        }
 
        public static bool operator !=(Point point1, Point point2)
        {
            return !(point1 == point2);
        }
    }
}

The following example fixes the above violation by overriding Object.Equals.

[C#]
 
using System;
 
namespace Samples
{
    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 int GetHashCode()
        {
            return _X ^ _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;
        }
 
        public static bool operator ==(Point point1, Point point2)
        {
            return Object.Equals(point1, point2);
        }
 
        public static bool operator !=(Point point1, Point point2)
        {
            return !Object.Equals(point1, point2);
        }
    }
}
Tags What's this?: Add a tag
Flag as ContentBug
Example using a structure      David M. Kean - MSFT   |   Edit   |   Show History

The following example show a structure (value type) that violates this rule.

[C#]
 
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; }
        }
 
        public override int GetHashCode()
        {
            return _X ^ _Y;
        }
 
        public static bool operator ==(Point point1, Point point2)
        {
            if (point1._X != point2._X)
                return false;
            
            return point1._Y == point2._Y;
        }
 
        public static bool operator !=(Point point1, Point point2)
        {
            return !(point1 == point2);
        }
    }
}

 

The following examples fixes this violation by overriding ValueType.Equals.

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);
        }
    }
}
Tags What's this?: Add a tag
Flag as ContentBug
© 2009 Microsoft Corporation. All rights reserved. Terms of Use | Trademarks | Privacy Statement | Site Feedback
Page view tracker