比较两个不同枚举的最佳方法是什么？

Question

I'm thinking what is the best way to compare values from two different enums.

Example:

public enum ExampleEnumA
{
    ExampleValue
}

public enum ExampleEnumB
{
    ExampleValue
}

 if (ExampleEnumA.ExampleValue.ToString() == ExampleEnumB.ExampleValue.ToString())
 {

 }

Comparing strings work, but I know that it's not the most efficient and eligent way. How it can be done better?

EDIT:

Maybe it's a design flaw, but it's problem from a real project, not my incorrect understanding of enums. This is how it looks like and there was no time to refactor whole approach.

public interface IProvider
{
    Enum SectionType { get; }
}

public class FirstProvider : IProvider
{
    public Enum SectionType
    {
        get { return ExampleEnumA.ExampleValue; }
    }
}

public class SecondProvider : IProvider
{
    public Enum SectionType
    {
        get { return ExampleEnumB.ExampleValue; }
    }
}

public class Program
{
    public void TmpMethod(Enum sectionType)
    {
        var provider = GetFromIoC...

        if (provider.SectionType == sectionType)
        {
            //...
        }
    }
}

Answer 1

Enumerations are like an abstraction layer on top a regular class of integer-based constants.

That abstraction includes evaluating false even if two enumeraiton values are the same integer but belong to different enumeration types.

What's the best way of comparing two different enumeration types with same underlying value? I would answer that it should be a design flaw if you need to perform this evaluation .

For example, let's say we've implemented these enumerations:

public enum States
{
    Open = 1, 
    Closed
}

public enum SpecialFolders 
{
     ProgramFiles86 = 1,
     ProgramFiles64
}

Would make sense something like States.Open == SpecialFolders.ProgramFiles86 ? Potentially, they seem to be equal (they won't) because both enumeration values have an underlying value of 1 , but 1 doesn't mean the same if the enumeration type isn't the same.

It's like saying that...

1. Bread
2. Meat

...is the same as:

1. Steal (Bread == Steal????????????)
2. Wood

Maybe...

...you can defeat the purpose of typing constants as enumerations casting them to int :

if ((int)ExampleEnumA.ExampleValue == (int)ExampleEnumB.ExampleValue)
{

}

...if the underlying type is int . It could also be long :

public enum SomeEnum : long 
{
}

...and you would need to cast left and right part of your evaluation to long , and so on.

Anyway, I insist that you shouldn0t go this way. Maybe you should use a regular class of constants instead and you'll avoid 2 casts per evaluation:

public static class States
{
     public const int Open = 1;
     public const int Closed = 2;
}

public static class Materials
{
    public const int Steel = 1;
    public const int Wood = 1;
}

// true! but not that true... I can't understand why these constants equal...
if(States.Open == Materials.Wood)
{
}

BTW, I still consider this a design flaw and you should avoid not using enumerations to workaround a bad design decision.