Почему я могу присвоить значениям перечисления 0,0, а не 1,0

Question 1

Просто из любопытства: почему я могу присвоить переменной перечислимого типа 0,0, а не 1,0? Взгляните на следующий код:

public enum Foo
{
    Bar,
    Baz
}

class Program
{
    static void Main()
    {
        Foo value1 = 0.0;
        Foo value2 = 1.0;   // This line does not compile
        Foo value3 = 4.2;   // This line does not compile
    }
}

Я думал, что преобразования между числовыми типами и значениями перечисления разрешены только через приведения? То есть я мог бы написать Foo, value2 = (Foo) 1.0;чтобы Mainможно было скомпилировать строку 2 . Почему 0.0в C # есть исключение для значения ?

Question 2

Это ошибка, которую вы можете использовать в 0.0. Компилятор неявно обрабатывает все константные выражения с нулевым значением как просто 0.

Теперь, это правильно для компилятора , чтобы неявное преобразование из постоянного intвыражения 0 до вашего перечисления согласно разделу 6.1.3 C # 5 спецификации:

Неявное преобразование перечисления позволяет преобразовать десятично-целочисленный литерал 0 в любой перечисляемый тип и в любой обнуляемый тип, базовым типом которого является перечисляемый тип. В последнем случае преобразование оценивается путем преобразования в базовый enum-type и упаковки результата (§4.1.10).

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

Mono mcsкомпилятор запрещает все эти преобразования с плавающей точкой, хотя это позволит:

const int Zero = 0;
...

SomeEnum x = Zero;

несмотря на то, что Zeroэто постоянное выражение, а не десятично-целочисленный литерал.

Я не удивлюсь, если в будущем спецификация C # изменится, чтобы разрешить любое целочисленное постоянное выражение со значением 0 (то есть имитировать mcs), но я не ожидал бы, что преобразования с плавающей запятой когда-либо будут официально правильными. (Я, конечно, ошибался, предсказывая будущее C # ...)

Question 3

Ответ Джона правильный. Я бы добавил к этому следующие моменты.

Я вызвал эту глупую и неприятную ошибку. Много извинений.
Ошибка была вызвана тем, что я неправильно понял семантику предиката "выражение равно нулю" в компиляторе; Я полагал, что он проверял только целочисленное равенство нулю, тогда как на самом деле он проверял больше по строкам «это значение по умолчанию для этого типа?» Фактически, в более ранней версии ошибки действительно можно было присвоить перечислению значение по умолчанию любого типа! Теперь это только значения чисел по умолчанию. (Урок: внимательно назовите свои вспомогательные предикаты.)
Поведение, которое я пытался реализовать, которое я испортил, на самом деле было обходным путем для немного другой ошибки. Вы можете прочитать всю ужасную историю здесь: https://docs.microsoft.com/en-us/archive/blogs/ericlippert/the-root-of-all-evil-part-one и https://docs.microsoft .com / en-us / archive / blogs / ericlippert / the-root-of-all-evil-part-two (Урок: очень легко вводить новые худшие ошибки, исправляя старые).
Команда C # решила закрепить это ошибочное поведение, а не исправлять его, потому что риск взлома существующего кода без существенной выгоды был слишком высок. (Урок: сделай это правильно с первого раза!)
Код , который я написал в Рослин , чтобы сохранить это поведение можно найти в методе IsConstantNumericZeroв https://github.com/dotnet/roslyn/blob/master/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/ConversionsBase.cs - см. дополнительные сведения о поведении Roslyn. Я написал почти весь код в каталоге Conversions; Я рекомендую вам прочитать все это, поскольку в комментариях есть много интересных фактов о том, как C # отличается от спецификации. Я украсил каждую НАРУШЕНИЕМ СПЕЦИФИКАЦИИ, чтобы их было легко найти.

Еще один интересный момент: C # также позволяет использовать любое значение перечисления в инициализаторе перечисления независимо от его нулевой точки:

enum E { A = 1 }
enum F { B = E.A }  // ???

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

Question 4

Перечисления в C # по определению являются целыми значениями. Для согласованности C # не должен принимать ни одно из этих назначений, но 0.0он молча считается интегральным 0. Вероятно, это пережиток C, где литерал 0обрабатывался специально и мог по существу принимать любой заданный тип - целое число, число с плавающей запятой, нулевой указатель… вы называете это.

Question 5

enum действительно предназначен (на всех поддерживающих его языках) как способ работы с осмысленными и уникальными строками (метками), а не с числовыми значениями. Таким образом, в вашем примере вы должны использовать только Bar и Baz при работе с перечисляемым типом данных Foo . Вы никогда не должны использовать (сравнивать или присваивать) целое число, даже если многие компиляторы позволят вам уйти от этого (перечисления обычно являются целыми числами внутри), и в этом случае 0,0 неосторожно обрабатывается компилятором как 0.

По идее, должно быть нормально добавить целое число n к перечисляемому значению, чтобы получить n значений дальше по строке, или взять val2 - val1, чтобы увидеть, насколько они удалены друг от друга, но если спецификация языка явно не разрешает это, я бы избежать этого. (Думайте о перечисляемом значении как о указателе C в том, как вы можете его использовать.) Нет причин, по которым перечисления не могут быть реализованы с числами с плавающей запятой и фиксированным приращением между ними, но я не слышал о это делается на любом языке.