Чому я можу призначити 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;щоб рядок 2 в Mainкомпілювався. Чому існує виняток для значення 0.0в C #?

Question 2

Це помилка, яку ви можете використовувати 0.0. Компілятор неявно розглядає всі константні вирази зі значенням нуля як просто 0.

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

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

Я вже говорив з командою C # про це раніше: вони хотіли б видалити випадкове перетворення з 0.0 (і справді 0.0m і 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 - подивіться, щоб дізнатись більше про те, якою саме є поведінка Росліна. Я написав майже весь код у каталозі Conversions; Я закликаю вас прочитати це все, оскільки у коментарях є багато цікавих фактів про те, як C # відхиляється від специфікації. Кожен я прикрасив SPEC VIOLATION, щоб їх було легко знайти.

Ще одна цікавинка: 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.

Концептуально, все в порядку повинно додати ціле число n до перерахованого значення, отримати n значень далі по рядку або взяти val2 - val1, щоб побачити, наскільки вони віддалені, але якщо специфікація мови це явно не дозволяє, I уникав би цього. (Подумайте про перераховане значення як про вказівник на С, таким чином, як ви можете ним скористатися.) Немає жодної причини, коли перелічення не можуть бути реалізовані з числами з плаваючою комою та фіксованим приростом між ними, але я не чув про це робиться будь-якою мовою.