Method parameter with strongly typed Enum type

Question

Consider the following code

enum HorizontalAlignment { Left, Middle, Right };
enum VerticleAlignment { Top, Middle, Bottom };

function OutputEnumValues (Type enumType)
{
    foreach (string name in Enum.GetNames(typeof(enumType)))
    {
        Console.WriteLine(name);
    }
}

Which can be called like

OutputEnumValues (typeof(HorizontalAlignment));
OutputEnumValues (typeof(VerticleAlignment ));

But I could inadvertantly call, for example

OutputEnumValues (typeof(int));

And this will compile but fail at runtime at Enum.GetNames()

Any way of writing the method signature to catch this sort of problem at compile time - i.e. only accepting enum types in OutputEnumValues?

Answer 1

Every enum type is just an integer (which can be 8-, 16-, 32- or 64-bit and signed or unsigned). You can cast the integer 0 to any enum type, and it will become a value that is statically typed to the enum.

Furthermore, you can have a parameter of type Enum to ensure that only enum values are passed in, without knowing the actual enum type.

Thus, my solution looks like this:

public static void OutputEnumValues(Enum example)
{
    foreach (string name in Enum.GetNames(example.GetType()))
    {
        Console.WriteLine(name);
    }
}

and then:

OutputEnumValues((HorizontalAlignment) 0);
OutputEnumValues((VerticalAlignment) 0);

This works for all enum types no matter their underlying integer type.

Answer 2

I don't think that this is possible in C#.

You could instead use an extension method on Enum, but this would require you to call it on an instance rather than the type itself which may not be desirable.

An alternative solution using generics that gets you part of the way is to constraint to structs:

public static void OutputValues<T>() where T : struct
{
    if (!typeof(T).IsEnum)
        throw new NotSupportedException("Argument must be an enum.");

    // code here...
}

This will give a compile time error if you try to call it with a class but a runtime error if you call it with a struct that is not an Enum.

Answer 3

What you really want here is a Generic method that could constrain to a Enum type. However, that isn't possible in C#.

Jon Skeet has an answer for this very problem in this thread: Anyone know a good workaround for the lack of an enum generic constraint?

For your method what you really want is

public void OutputEnumValues<T>() where T : HorizontalAlignment
{
    foreach (string name in Enum.GetNames(typeof(T)))
    {
        Console.WriteLine(name);
    }
}

But that constraint won't work, unless you use Jon's suggestion.

Answer 4

I don't see the "problem" as you state it.

You define your method to take a Type object. To clients, any Type would seem sufficient. However, you then assume that the argument is actually an enumeration. The bug is in your method itself. The method itself is contrived anyway, so it's impossible to get an idea of the problem you are actually trying to solve with code like this.

Then again, the name of your method makes it fairly obvious that the argument should be an enum value. You could consider that a contract, and if clients of the code violate that contract than it will blow up in their faces. Any API includes methods that you can send bad data to.