Почему Enums были скомпилированы как константы вместо статических значений?

Question

Я понимаю, что Enums скомпилированы как константы, поэтому их изменение приводит к нарушению изменения. Мне интересно, почему же не перечислил Enums так же, как статические переменные readonly?

Answer 1

Они могут быть более эффективными, чем поля, поэтому нет необходимости составлять их таким же образом, когда они могут быть непосредственно встроены в IL.

[Enums] загружаются в тот же способ загрузки значения const. Они встроены непосредственно в IL-код . С другой стороны, полям требуется инструкция полевой нагрузки (ldsfld), которая будет несколько влиять на производительность. Таким образом, перечислены так же быстро, как const при типичном использовании; поля несколько медленнее.

(Source)

Answer 2

От enum (C# Reference)

Так же, как с любой константой, все ссылки на отдельные значения перечисления преобразуются в числовые литералы во время компиляции

Так что я что-то упускаю?

Answer 3

Оба эти ответы технически правильны, но не дают объяснений различительных констант со статикой (только для чтения). В C#, константы всегда быстрее, чем только для чтения, и причина очень проста и лучше всего выражается с небольшим кодом, например:

const int MyConstant = 10; 
static readonly int MyReadonly = 20; 

static void Main() 
{ 
    int result = MyConstant + MyReadonly; 
    // the above statement will be resolved to: 
    // int result = 10 + MyReadonly 
} 

Во время компиляции, компилятор заменяет все ссылки на константу с фактическим значением этого постоянная , Он может это сделать, потому что константа должна быть предопределена во время компиляции. Это отличается от статических значений readonly, которые, хотя и статичны, фактически разрешены во время выполнения. Рассмотрим следующий пример:

static readonly Encoding = Encoding.GetEncoding("GB2132"); 

Там нет никакого способа для компилятора знать, если GB2132 действительно существует на машине, на которой этот код предназначен для запуска. Единственный способ разрешить это значение - во время выполнения. Static гарантирует, что само значение не привязано к времени жизни экземпляра и readonly гарантирует, что значение может быть установлено только один раз. Компилятор не может заменить ссылки на это поле во время компиляции, так как значение просто невозможно узнать.

Логически только примитивные типы могут быть отмечены как постоянные.

Теперь в случае перечислений это очень просто. Перечисления - это не что иное, как целочисленное значение с меткой. Таким образом, следующий код:

enum MyEnum 
{ 
    First, 
    Second, 
    Third 
} 

static void Main() 
{ 
    MyEnum test = MyEnum.First; 

    if (test == MyEnum.Second) 
    { 
     // whatever 
    } 
} 

Будет решена компилятором:

const int MyEnum_First = 0; 
const int MyEnum_Second = 1; 
const int MyEnum_Third = 2; 

static void Main() 
{ 
    int test = MyEnum_First; 

    if (test == MyEnum_Second) 
    { 
     // whatever 
    } 
} 

Что в свою очередь означает, что фактические ссылки на постоянные поля могут быть заменены значением, известным во время компиляции, что делает окончательная версия кода:

static void Main() 
{ 
    int test = 0; 

    if (test == 1) 
    { 
     // whatever 
    } 
}