Why the default enum value is 0 and not the minimum one?

Question

What's the point of having '0' as a default value for enum in C#? If I declare enumeration that starts with a different number:

enum Color
{
   Blue = 1,
   Green,
   Red,
}

then var color = default(Color) - will return me '0'. I expected to see the minimum value instead. This behavior may cause problems if each member of the enumeration corresponds to some specific number and '0' is not a valid value.

Answer 1

Default value for all value types (including enum) is bitwise 0. As result it means that 0 is always possible value for enum even if it is not explicitly defined.

Here is the specification: Default values table

EDIT: for more details check MSDN for enumeration types - enum

enum is type which is special in a way the it sort-of derives from other value type (which normally not possible), but behaves as value type of its backing type. An enum can use only some integral values as backing type.

Note: as @archil points out enum value may contain any value of backing type, irrespective of list of constants enumerated in enum itself. For enums marked with "FlagsAttribute" this behavior is normally expected, but for normal enums it may not be intuitive.

Answer 2

We can only conjecture about why an aspect of the .NET framework was designed a certain way. For the most straightforward explanation, I'd like to highlight this remark from the MSDN documentation:

An enumeration is a set of named constants whose underlying type is any integral type except Char. If no underlying type is explicitly declared, Int32 is used.

Note that a .NET enumeration is essentially an extension of an integral type. The default value for integral types is 0, so it's reasonable (if somewhat inconvenient in the cases you've illustrated) for enumerations to inherit that behaviour.

Answer 3

There always is possibility for enum to have non-existent value. That is why Enum.IsDefined Method exists.

The default value of an enum E is the value produced by the expression (E)0.

Answer 4

As has been stated in multiple answers so far, the "default" value for any fixed-size data structure is 0. The size of the structures memory is set to zero and that is considered "default". Now, if you want to define your own "default" value for an enum, you have multiple options. The easiest would be to write your own function to give you a "minimum valid enum"

private E GetDefaultEnum<E>()
{
    return (E)(Enum.GetValues(typeof(E)).Cast<E>().Min<E>());
}

Usage:

enum Color
{
   Blue = 1,
   Green,
   Red,
}

Color defaultColor = GetDefaultEnum<Color>();
MessageBox.Show(defaultColor.ToString()); // "Blue"

You can obviously alter how you determine a "default" value, but this way seems best suited to your needs.

Answer 5

Why is 0 the default enum value? Ease of runtime implementation. The default of any value type is bitwise 0, and presumably a null reference is represented by bitwise 0. Thus to initially construct an object with its default values, we only need to know its size; the runtime doesn't need to know or process anything about the object's structure. Similarly, the pre-defined value-type constructor can merely fill a memory range with zeroes.

Like it or not, that's how it is. What we need to do in response is when designing an enum, whatever name is a suitable default, give it the value 0. If there is no suitable default, then your methods accepting such an enum as a parameter might check that it's properly set, e.g.

void ProcessColor(Color c) {
    if (c == 0)
        throw new ArgumentException("Color is not set", "c");
    //...
}

Answer 6

The point is probabbly is in having less positive integer possible value.

Why less positive?

To be able to treat enum with bit-shift operation correctly.

I'm naturally talking about default value, that can be changed by developer.

Answer 7

I am not sure why but...

Here is the doc about C# enum: http://msdn.microsoft.com/en-us/library/sbbt4032.aspx

Enumerators can use initializers to override the default values, as shown in the following example.

enum Days {Sat=1, Sun, Mon, Tue, Wed, Thu, Fri};

In this enumeration, the sequence of elements is forced to start from 1 instead of 0. However, including a constant that has the value of 0 is recommended. For more information, see Enumeration Types (C# Programming Guide).

They recommend you always include a placeholder enum value which corresponds to the value 0 otherwise you may run into problems. You could name this enum value something like Undefined or Default or something like that.

As I mentioned in my comment to your question though, my recomendation would be to not use values for your enums at all unless you have a very good reason for doing so. If you need to, follow the MSDN Programming Guide for Enumeration Types

Answer 8

enum is int (by default). Enums are human-readable ints for our source code, but when your program gets compiled, there is no enum, only ints. The default value for int is 0.

This code:

public enum test { One, Two, Three }

var x = test.One;
var y = 0;

Becomes this in IL:

IL_0001:  ldc.i4.0   
IL_0002:  stloc.0     
IL_0003:  ldc.i4.0    
IL_0004:  stloc.1 

So, how could an int have a default value of 1 (as you ask) in some cases, but not others?