c# enum equals() vs ==
In the case of using enums, is it better to use:
if (enumInstance.Equals(MyEnum.SomeValue))
or to use
if (enumInstance == MyEnum.SomeValue)
Are their any important considerations using one vs the other?
If the compile-time type of enumInstance
is the enum type, you're fine with ==
.
If the compile-time type of enumInstance
is Enum
, ValueType
or Object
, you need to use Equals
. (You'll get a compile-time error if you try to use ==
in that case.)
Note that your enum currently violates .NET naming conventions - it would normally be MyEnum.Value
.
Using == instead of Equals is a bit quicker, there is no need to box enums and no functions calls needed here is sample c# code and generated MSIL for it:
class Program
{
static void Main(string[] args)
{
var instance = MyEnum.First;
if (instance == MyEnum.First)
{
Console.WriteLine("== Called");
}
if (instance.Equals(MyEnum.First))
{
Console.WriteLine("Equals called");
}
}
}
enum MyEnum { First = 99, Second = 100}
MSIL:
IL_0000: nop
IL_0001: ldc.i4.s 99
IL_0003: stloc.0
IL_0004: ldloc.0
IL_0005: ldc.i4.s 99
IL_0007: ceq
IL_0009: ldc.i4.0
IL_000a: ceq
IL_000c: stloc.1
IL_000d: ldloc.1
IL_000e: brtrue.s IL_001d
IL_0010: nop
IL_0011: ldstr "== Called"
IL_0016: call void [mscorlib]System.Console::WriteLine(string)
IL_001b: nop
IL_001c: nop
IL_001d: ldloc.0
IL_001e: box ConsoleApplication1.MyEnum
IL_0023: ldc.i4.s 99
IL_0025: box ConsoleApplication1.MyEnum
IL_002a: callvirt instance bool [mscorlib]System.Object::Equals(object)
IL_002f: ldc.i4.0
IL_0030: ceq
IL_0032: stloc.1
IL_0033: ldloc.1
IL_0034: brtrue.s IL_0043
IL_0036: nop
IL_0037: ldstr "Equals called"
IL_003c: call void [mscorlib]System.Console::WriteLine(string)
IL_0041: nop
IL_0042: nop
IL_0043: ret
As you can see == generates ceq instruction, Equals method performes boxing and callvirt
As an extension to Jon Skeet's old answer, it is true that you get a compilation error when you compare Enum == YourActualEnum.Value
, however when you do Enum == Enum
, which compiles fine, it return false all the time.
public class TestClass
{
public bool TestMethod1()
{
bool Result = false;
Enum l_Value = TEST_ENUM.TEST_VALUE_1;
Enum l_Check_Value = TEST_ENUM.TEST_VALUE_1;
Result = l_Value == l_Check_Value;
return Result;
}
public bool TestMethod2()
{
bool Result = false;
TEST_ENUM l_Value = TEST_ENUM.TEST_VALUE_1;
TEST_ENUM l_Check_Value = TEST_ENUM.TEST_VALUE_1;
Result = l_Value == l_Check_Value;
return Result;
}
public bool TestMethod3()
{
bool Result = false;
Enum l_Value = TEST_ENUM.TEST_VALUE_1;
Enum l_Check_Value = TEST_ENUM.TEST_VALUE_1;
Result = l_Value.Equals(l_Check_Value);
return Result;
}
public enum TEST_ENUM
{
TEST_VALUE_1,
TEST_VALUE_2,
TEST_VALUE_3
}
}
if you try the following on a test app you'll get the following
Console.WriteLine("Method 1 result: {0}", myClass.TestMethod1());
Console.WriteLine("Method 2 result: {0}", myClass.TestMethod2());
Console.WriteLine("Method 3 result: {0}", myClass.TestMethod3());
you will get the following results
Method 1 result: False
Method 2 result: True
Method 3 result: True
If you wonder why would you ever compare Enum against Enum....I discovered it while trying to be smart while creating an EnumConverter and a FlagConvert for a WPF project. There you receive only an object value as parameter and for the flag converter specifically i wanted to provide a special text for when no flag was selected (i.e. the enum has a value of 0 which has no static member for it).
Nothing else worked (including value.Equals(0), value.Equals((int)0) ) except this:
l_Source_Type = value.GetType();
if (l_Source_Type.IsDefined(typeof(FlagsAttribute)))
{
Enum l_Value = (Enum)value;
Enum l_Check_Value = (Enum)Enum.ToObject(l_Source_Type, 0);
if (l_Value.Equals(l_Check_Value))
{
return String.Empty;
}
}
There is a case that the other answers here have not mentioned that may help others.
With c# the underlying type of an enum is an integral. Because it is an integral, you can logically OR the enums together.
When using either of the above methods for equality will fail if enums are logically OR'd together.
So for some special cases, such as using enums as flags, you will need to logically AND the case you are testing for with first prior to checking for equality.
if ((enumInstance & MyEnum.SomeValue).Equals(MyEnum.SomeValue))
or
if ((enumInstance & MyEnum.SomeValue) == MyEnum.SomeValue)
Strictly speaking it's safest to use "==" with enums.
A complete list of possible enum types can be found here: https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/enum