When are two enums equal in C#?

Question

I have created two enums and I know they are not the same but still I think it makes sense they would be equal since their string representation as well as their numeral representation are equal (and even the same...).

In other words : I would like the first test to pass and the second one to fail. In reality however, they both fail. So : when are two enums in C# equal? Or is there anyway to define the equals operator in C#?

Thanks!

 public enum enumA {one, two}

 public enum enumB {one, two}

 [Test]
 public void PreTest()
 {   
 Assert.AreEqual(enumA.one,enumB.one);
 Assert.AreSame(enumA.one, enumB.one);
 }

UPDATE : 1) So the answers so far all compare representations, be it ints or strings. The enum itself is always unequal I gather? No means to define equality for it?

Answer 1

    public enum enumA {one = 1, two = 2}

    public enum enumB {one = 1, two = 2}

    [Test]
    public void PreTest()
    {                       
        Assert.AreEqual((int)enumA.one, (int)enumB.one);
        // I don't think this one will ever pass
        Assert.AreSame(enumA.one, enumB.one); 
    }

Answer 2

If you want them to match, cast them to int

Assert.AreEqual((int)enumA.one,(int)enumB.one);

would pass because they are both the first listed. If you wanted them to match because they both say "one" then you need to use reflection.

Answer 3

You could try casting them:

Assert.AreEqual((int)enumA.one, (int)enumB.one);

Answer 4

Enums are strongly typed in C#, hence enumA.one != enumB.one. Now, if you were convert each enum to their integer value, they would be equal.

Assert.AreEqual((int)enumA.one, (int)enumB.one);

Also, I'd like to challenge the statement that because they have the same integer or string representation that they should be the same or equals. Given two enumerations NetworkInterface and VehicleType, it would not be logical for C# or the .Net Framework to allow NetworkInterface.None to equal VehicleType.None when compared as enumeration, by either value or string. However, if the developer cast the strongly typed enumeration to an integer or string, there is nothing the language or framework can do to stop the two from being equals.

To further clarify, you cannot override MyEnum.Equals in order to provide a different equality method. .Net enums are not quite the first class citizens they are in later versions of Java, and I wish that C# allowed for richer interactions with Enums.

Answer 5

To be honest, Equality is not straight forward most of the time.

I would be inclined to create a helper class that implements IEqualityComparer (and any other equality tests, IsSame() for example) and use that.

Answer 6

I refer you to the C# Language Specification v3.0, from which this quote has been extracted from the Enum section on page 29:

"Each enum type has a corresponding integral type called the underlying type of the enum type. An enum type that does not explicitly declare an underlying type has an underlying type of int. An enum type’s storage format and range of possible values are determined by its underlying type. The set of values that an enum type can take on is not limited by its enum members. In particular, any value of the underlying type of an enum can be cast to the enum type and is a distinct valid value of that enum type."

The .AreEqual method is really testing equivalence while the second tests identity. So, simply cast each one to its underlying type (in this case, int) and then do the comparison.

public enum enumA { one, two }
public enum enumB { one, two }
[Test]
public void PreTest()
{
        Assert.AreEqual((int)enumA.one,(int)enumB.one);
        Assert.AreSame(enumA.one, enumB.one);
}

Answer 7

Unlike Java, C# does not provide any facility for adding methods (such as operator==()) to an enum.

What I have done in the past when needing smarter enums is create an XHelper class (where X is the name of the enum), and I put all of the methods on it. Thus something like this:

public static bool EnumAHelper.EqualsEnumB(EnumA enumA, EnumB enumB)
{
    return (int)enumA == (int)enumB;
}

Though, I do not recall running into a case where I needed two different enums to signify the same thing.