Enumeration is a value type, while System. Enum is a reference type.

Q: In C #, how do we express enumeration types?

A: You can use the enum keyword (keyword) to declare an enumeration type (enum type ):

 
 

  
  
// Code #01  
  
  
public enum Alignment  
  
  
{  
  
  
    Left,  
  
  
    Center,  
  
  
    Right  
  
  
}  
 
 

--------------------------------------------------------------------------------
Q: C # Is the enumerated type value type or reference type )?

A: All enumeration types are value types.

--------------------------------------------------------------------------------

Q: Is System. Enum an enumeration type?

A: No.

--------------------------------------------------------------------------------

Q: What is the relationship between System. Enum and enum type?

A: System. Enum is an abstract class. All enumeration types are directly inherited from it, and of course all its members are inherited.

--------------------------------------------------------------------------------

Q: Why does System. Enum belong to the reference type?

A: Yes.

--------------------------------------------------------------------------------

Q: Since System. Enum is a reference type and the enumeration type is directly inherited from System. Enum, why is the enumeration type not a reference type?

A: This inheritance relationship is implicitly expanded by the compiler. The above Code #1's Alignment enumeration is expanded with the following IL Code:

 
 

  
  
// Code #02  
  
  
.class public auto ansi sealed Aligment  
  
  
       extends [mscorlib]System.Enum  
  
  
{  
  
  
    .field public static literal Aligment Left = int32(0x00000000)  
  
  
    .field public static literal Aligment Center = int32(0x00000001)  
  
  
    .field public static literal Aligment Right = int32(0x00000002)  
  
  
 
  
  
    .field public specialname rtspecialname int32 value__  
  
  
}  
 
 

From the declaration, you can see that Aligment indeed inherits from System. Enum, but you cannot explicitly declare this inheritance relationship in C.

--------------------------------------------------------------------------------

Q: Why is the enumerated type still a value type after it is inherited from a reference type!

A: You know, all value types are System. the descendant of ValueType, And the enumeration type is no exception. The Enumeration type is directly inherited from System. enum, while System. the Enum is directly inherited from the System. valueType, so the enumeration type is also System. the descendant of ValueType.

--------------------------------------------------------------------------------

Q: slow! Shouldn't all types derived from System. ValueType be value types? Why is System. Enum a reference type?

A: The correct statement is that "All values are descendants of System. ValueType", but the descendants of System. ValueType are not all values. System. Enum is the only special case! Among all the descendants of System. ValueType, all except System. Enum are value types. In fact, we can find the declaration of System. Enum in the source code of. NET:

 
 

  
  
public abstract class Enum : ValueType, IComparable, IFormattable, IConvertible  
 
 

Note that the Enum declaration in. NET Framework SDK v2.0.3600.0 Documentation is incorrect:

Public abstract struct Enum: IComparable, IFormattable, IConvertible

--------------------------------------------------------------------------------

Q: I'm dizzy. What is the relationship between the C # Enumeration type, System. Enum, System. ValueType, value type, and reference type?

A: in short,

1. All enumeration types (enum type) are value types.
2. System. Enum and System. ValueType are reference types.
3. The enum type is implicitly directly inherited from System. Enum, and the inheritance relationship can only be automatically expanded by the compiler. However, System. Enum is not an enumeration type ).
4. System. Enum is a special case. It directly inherits from System. ValueType (see Code #03), but it is a reference type.
Okay. Now let's take a look at the following code. Can you guess the output result?

 
 

  
  
// Code #04  
  
  
static void Main()  
  
  
{  
  
  
    Type t = typeof(System.Enum);  
  
  
 
  
  
    if (t.IsEnum)  
  
  
        Console.WriteLine("I'm enum type.");  
  
  
 
  
  
    if (t.IsValueType)  
  
  
        Console.WriteLine("I'm value type.");  
  
  
}  
 
 

Don't be surprised that the running result of the program has no output! For the first judgment, we know that System. Enum is not an enumeration type. But what about the second judgment? System. Enum is inherited from System. ValueType, but it is not recognized as a descendant of System. ValueType! This is a special case in. NET. It just shows that System. Enum is special.

--------------------------------------------------------------------------------

Q: Since the enumeration type is a value type, it will naturally involve the boxing and unboxing problems, what will the enumeration type be packed? [Updated]

A: enumeration types can be boxed into System. Enum, System. ValueType, System. Object, System. IConvertible, System. IFormattable, and System. IComparable.

Note: In.. NET 1.1, the enumeration type can only be boxed to System. enum, System. valueType, System. object.. NET 2.0, the enumeration type can also be boxed to System. the three interfaces implemented by Enum: System. IConvertible, System. IComparable, System. IFormattable. The corresponding packing operation can be either implicit or explicit.

The following C # code:

 
 

  
  
// Code #05  
  
  
// See Code #01 for Alignment.  
  
  
static void Main()  
  
  
{  
  
  
    Alignment a = Alignment.Center;  
  
  
 
  
  
    Console.WriteLine(a.ToString());  
  
  
 
  
  
    Console.WriteLine(a);  
  
  
}  
 
 

The corresponding IL code is:

 
 

  
  
// Code #06  
  
  
.method private hidebysig static void Main() cil managed  
  
  
{  
  
  
    .entrypoint  
  
  
    // Code Size: 32 byte(s)  
  
  
    .maxstack 1  
  
  
    .locals (  
  
  
          EnumerationFaq.Alignment alignment1)  
  
  
    L_0000: ldc.i4.1   
  
  
    L_0001: stloc.0   
  
  
    L_0002: ldloc.0   
  
  
    L_0003: box EnumerationFaq.Alignment  
  
  
    L_0008: call instance string [mscorlib]System.Enum::ToString()  
  
  
    L_000d: call void [mscorlib]System.Console::WriteLine(string)  
  
  
    L_0012: nop   
  
  
    L_0013: ldloc.0   
  
  
    L_0014: box EnumerationFaq.Alignment  
  
  
    L_0019: call void [mscorlib]System.Console::WriteLine(object)  
  
  
    L_001e: nop   
  
  
    L_001f: ret   
  
  
}  
 
 

From the IL code, we can see that the enumeration type is boxed twice. The first time (L_0003) is packed into System. Enum, and the second time (L_0014) is packed into System. Object.

But if you ask the compiler to automatically select the packing type for you, it will give priority to System. Enum:

 
 

  
  
// Code #07  
  
  
// See Code #01 for Alignment.  
  
  
class Program  
  
  
{  
  
  
    static void Main()  
  
  
    {  
  
  
        Alignment a = Alignment.Center;  
  
  
 
  
  
        Print(a);  
  
  
    }  
  
  
 
  
  
    static void Print(IConvertible c)  
  
  
    {  
  
  
        Console.WriteLine(c);  
  
  
    }  
  
  
 
  
  
    static void Print(IFormattable f)  
  
  
    {  
  
  
        Console.WriteLine(f);  
  
  
    }  
  
  
 
  
  
    static void Print(IComparable c)  
  
  
    {  
  
  
        Console.WriteLine(c);  
  
  
    }  
  
  
 
  
  
    static void Print(Object o)  
  
  
    {  
  
  
        Console.WriteLine(o);  
  
  
    }  
  
  
 
  
  
    static void Print(ValueType v)  
  
  
    {  
  
  
        Console.WriteLine(v);  
  
  
    }  
  
  
 
  
  
    static void Print(Enum e)  
  
  
    {  
  
  
        Console.WriteLine(e);  
  
  
    }  
  
  
}  
 
 

The above code will be compiled into the following IL:

1. // Code #08
2. . MethodPrivateHidebysigStatic VoidMain (String[] Args) Pencil managed
3. {
4. . Entrypoint
5. // Code Size: 15 bytes (s)
6. . Maxstack 1
7. . Locals (
8. EnumerationFaq. Alignment alignment1)
9. L_0000: ldc. i4.1
10. L_0001: stloc.0
11. L_0002: ldloc.0
12. L_0003: box EnumerationFaq. Alignment
13. // Call static void Print (Enum e );
14. L_0008: callVoidEnumerationFaq. Program: Print ([mscorlib] System. Enum)
15. L_000d: nop
16. L_000e: ret
17. }

Statement: This article Reprinted from http://developer.51cto.com/art/200908/143309.htm