How can I get the number of enums as a constant?

Question

From Total number of items defined in an enum, I see I can get the number of enums by using:

Enum.GetNames(typeof(Item.Type)).Length;

Works great!

But, I need this number as a constant number, so that I can use it in Unity's [Range(int, int)] feature.

private const int constEnumCount = Enum.GetNames(typeof(Item.Type)).Length;

The above does not work, because the enum count is not a constant number, so I cannot assign it to a constant variable.

How can I get the number of enums as a constant?

Answer 1

It's not possible to get the number of enums as a const. Enum.GetNames uses reflection to get these things, and that's inherently a runtime operation. Therefore, it can't be known at compile time, which is a requirement for being const.

Answer 2

Unfortunately, this is not possible to do in any meaningful way due to technical limitations:

• [Range(int,int)] is an attribute, and all information provided to an attribute has to be a const
• The only truly bulletproof way to get the number of values in an enum is to use Enum.GetValues(typeof(MyEnum)).Length or the Enum.GetNames(typeof(MyEnum)).Length, both of which are run time reflection.

However, there are hacks that can sort of work. For example, the value of an enum can be cast to an integer. As long as nobody is explicitly defining values for your enums you can use the last element in your enum kind of like this:

[Range(0,(int)MyEnum.LastValue)]
public void BlahBlahBlah() {}

However, know that as soon as someone adds a new entry to the enum after the one you are using or reorders the elements in the enum, your code will break unpredictably and not behave like you want.

It's sad, but the C# compiler is not smart enough to do simple math in the compiler like Java, C, and C++ compilers. So even the example I gave would only really work if the LastValue wasn't ever used for anything except to mark the last element in the enum. It lowers the complexity of the C# compiler, which also greatly improves the compilation speed for your application. As such, there are some trade-offs that the C# and CLR team took to improve your experience in other places.

Answer 3

Assuming that you need a const because you are trying to specify the values for an Attribute (this one?) then you are out of luck.

Your options are:

1. Hardcode the count in the attribute declaration or as a const itself and be careful to keep the count in sync with the enum definition
2. Use PostSharp or some other aspect oriented framework to insert the attribute for you. Have never done this myself but it looks possible (How to inject an attribute using a PostSharp attribute?)

You could probably also finagle some way to so this with T4 templates but that would get excessively kludgy.

Were it me, unless you are talking but hundreds of different set of enumerations, I'd hardcode the length and maybe add an Assert where I needed it.

// WARNING - if you add members update impacted Range attributes
public enum MyEnum
{
    foo,
    bar,
    baz
}

[Range(0, 3)]
class Test
{
    public Test()
    {
        int enumCount = Enum.GetNames(typeof(MyEnum)).Length;
        int rangeMax = GetType().GetCustomAttributes(typeof(Range), false).OfType<Range>().First().Max;

        Debug.Assert(enumCount == rangeMax);
    }
    static void Main(string[] args)
    {
        var test = new Test();
    }
}

Answer 4

Super late to the game here but I've always used a nifty hack when using enum defaults (i.e. no custom values).

public enum MyEnum {
    foo,
    bar,
    baz,
    count
}

Since enums default to starting with 0, ensuring the last entry is named simply 'count' ensures that the value of count is in fact the number of values in the enum itself.

private const int constEnumCount = (int)MyEnum.count; 

Cheers!

Answer 5

You cannot assign/create a const at runtime. That is what you are trying to do. A const has to be fully evaluated at compile time, not runtime.

I am not sure about Unity (and why it requires a const), but I would look for using readonly

private readonly int constEnumCount = Enum.GetNames(typeof(Item.Type)).Length;

Answer 6

In C#, a const is defined as constant, i.e. the value (not the calculation which produced it!) is directly embedded in the compiled assembly.

To stop you from doing something problematic, the compiler does not allow you to assign the result of a calculation to a const. To understand why, imagine it were possible:

A.dll
  public enum Foo { A, B }

B.dll
  public const NumberOfFoos = Enum.GetNames(typeof(Foo)).Length;

// Compiles to:
B.dll
  public const NumberOfFoos = 2;

Now you change A.dll:

A.dll
  public enum Foo { A, B, C, D }

B.dll
      public const NumberOfFoos = 2; // Oh no!

So you would need to recompile B.dll to get the correct value.

It gets worse: Imagine you had an assembly C.dll, which uses B.NumberOfFoos. The value 2 would be directly embedded in C.dll, so it also would need to be recompiled, after B.dll, in order to get the correct value. Therefore (pit of success), C# does not allow you to do that assignment to a const.