Generated constants for enum values

Question

I'd need to store some properties of the enum's entries in their constants. For example indicate whether a color is cold or warm.

enum Colors
{
  Yellow, // warm
  Blue,   // cold
  Gray,   // cold
  Red,    // warm
  // etc.
}

In C++ I would define a macro to generate bitmasks for the constants. Something like:

#define WARM 1
#define COLD 0

#define MAKECOLOR(index, type) ((index << 8) | type)

enum Colors
{
  Yellow = MAKECOLOR(0, WARM),
  Blue   = MAKECOLOR(1, COLD),
  Gray   = MAKECOLOR(2, COLD),
  Red    = MAKECOLOR(3, WARM),
  // etc.
}

In C# this is not possible because there are no macros. I want to avoid writing bitmask expressions directly in the enum. Like this:

  ...
  Gray   = ((2 << 8) | 0),
  ...

Any ideas?

P.S.
Yes, I'm a syntactic sugar freak. :D

Ignacio Soler Garcia · Accepted Answer · 2011-08-18 12:29:22Z

3

You should use attributes at the enum values. Read this article, it's pretty good:

http://www.codeproject.com/KB/cs/enumwithdescription.aspx

Hope it helps!

answered Aug 18, 2011 at 12:29

Ignacio Soler Garcia

22k34 gold badges140 silver badges218 bronze badges

Sign up to request clarification or add additional context in comments.

3 Comments

armen Over a year ago

Good idea. The only question is how fast is the evaluation of the attributes.

Daniel A.A. Pelsmaeker Over a year ago

This solution does have the performance penalty of using reflection. If you want to include the property of each enumeration member in its value for speed, you might as well use a separate Warm/Cold array and use the enum member's integer value as index (e.g. warmcold[(int)Colors.Gray]. I think it is faster.

Ignacio Soler Garcia Over a year ago

Well, they are accessed thru reflection so don't expect the speed of light.

Daniel A.A. Pelsmaeker · Accepted Answer · 2011-08-18 13:17:36Z

2

I do tend to write the bit expression directly in the enum:

enum Colors
{
    Yellow = (0 << 8) | ColorTemp.Warm,
    Blue   = (1 << 8) | ColorTemp.Cold,
    Gray   = (2 << 8) | ColorTemp.Cold,
    Red    = (3 << 8) | ColorTemp.Warm,
}

enum ColorTemp
{
    Cold = 0,
    Warm = 1,
}

And then write a simple extension class at the bottom of the file, like this:

public static class ColorsExtensions
{
    public ColorTemp GetTemperature(this Colors color)
    {
        return (ColorTemp)(color & 0x01);
    }
}

edited Aug 18, 2011 at 13:17

answered Aug 18, 2011 at 12:31

Daniel A.A. Pelsmaeker

50.8k21 gold badges118 silver badges162 bronze badges

2 Comments

armen Over a year ago

This is how to acquire the property. Instead, I need a way to define it.

user195488 Over a year ago

@armen: This is the only correct way to do it. Otherwise, it won't work.

user195488 · Accepted Answer · 2011-08-18 12:56:34Z

0

In C#, enum need to have const values defined at compile-time. In sum, C# is more const than C++.

In C#, const is used to denote a compile-time constant expression. It'd be similar to this C++ code:

enum {
  count = buffer.Length;
}

Because buffer.Length is evaluated at runtime, it is not a constant expression, and so this would produce a compile error.

C# has a readonly keyword which is a bit more similar to C++'s const. (It's still much more limited though, and there is no such thing as const-correctness in C#).

const is meant to represent a compile-time constant... not just a read-only value.

You can't specify read-only but non-compile-time-constant local variables in C#, I'm afraid. Some local variables are inherently read-only - such as the iteration variable in a foreach loop and any variables declared in the first part of a using statement. However, you can't create your own read-only variables.

If you use const within a method, that effectively replaces any usage of that identifier with the compile-time constant value.

So, you are going to have to define your values at compile-time in your enum. They cannot be evaluated at run-time. Those are the rules.

answered Aug 18, 2011 at 12:56

user195488

4 Comments

Vlad Over a year ago

Well, expressions like (3 << 8) | Warm are evaluated at compile-time. The difference between (3 << 8) | Warm and static function call is just a question of powerful optimizer.

user195488 Over a year ago

@Vlad: I tried it in C# with a static function call and the compiler blew up complaining that it must be a constant. When I did it like @Virtlink did, it works because it is evaluated at compile-time in the enum.

Vlad Over a year ago

This basically means that the language's optimizer is shy and doesn't want to show its full strength evaluating constant expressions at compile time, not that it's not possible at all. After all, the considered expression is a compile-time constant.

user195488 Over a year ago

@Vlad: That's what I thought too except the compiler shipped with Visual Studio 2010 does not allow me to do this so that led me down the road that it simply is not possible with C# like it is with C++.

Collectives™ on Stack Overflow

Generated constants for enum values

3 Answers 3

3 Comments

2 Comments

4 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

3 Comments

2 Comments

4 Comments

Your Answer

Sign up or log in

Post as a guest

Related