Perché posso assegnare 0,0 ai valori di enumerazione, ma non 1,0

Solo per curiosità: perché posso assegnare 0.0 a una variabile che è di tipo enumerativo, ma non 1.0? Dai un'occhiata al seguente codice:

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
    }
}

Ho pensato che le conversioni tra tipi numerici e valori di enumerazione fossero consentite solo tramite cast? Cioè potrei scrivere Foo in value2 = (Foo) 1.0;modo che la riga 2 Mainpossa essere compilata. Perché c'è un'eccezione per il valore 0.0in C #?

È un bug che puoi usare 0.0. Il compilatore tratta implicitamente tutte le espressioni costanti con un valore zero come solo 0.

Ora, è corretto che il compilatore consenta una conversione implicita da intun'espressione costante di 0 alla tua enum secondo la sezione 6.1.3 della specifica C # 5:

Una conversione di enumerazione implicita consente di convertire il valore letterale intero decimale 0 in qualsiasi tipo enum e in qualsiasi tipo nullable il cui tipo sottostante è un tipo enum. In quest'ultimo caso la conversione viene valutata convertendola nel sottostante tipo enum e avvolgendo il risultato (§4.1.10).

Ne ho già parlato con il team C #: avrebbero voluto rimuovere la conversione accidentale da 0.0 (e in effetti 0.0m e 0.0f) ai valori enum, ma sfortunatamente ho capito che ha rotto troppo codice, anche se in primo luogo non avrebbe mai dovuto essere consentito.

Mono mcscompilatore vieta tutte queste conversioni virgola mobile, anche se non permette:

const int Zero = 0;
...

SomeEnum x = Zero;

nonostante Zerosia un'espressione costante ma non un numero intero decimale letterale.

Non sarei sorpreso di vedere la modifica della specifica C # in futuro per consentire qualsiasi espressione costante intera con un valore di 0 (cioè per imitare mcs), ma non mi aspetto che le conversioni in virgola mobile siano mai ufficialmente corrette. (Mi sono sbagliato prima sulla previsione del futuro di C #, ovviamente ...)

La risposta di Jon è corretta. Aggiungo i seguenti punti.

• Ho causato questo bug stupido e imbarazzante. Molte scuse.

• Il bug è stato causato dalla mia incomprensione della semantica di un predicato "expression is zero" nel compilatore; Credevo stesse controllando solo l'uguaglianza di zero interi, quando in realtà stava controllando di più sulla falsariga di "è questo il valore predefinito di questo tipo?" Infatti, in una versione precedente del bug era effettivamente possibile assegnare il valore predefinito di qualsiasi tipo a un enum! Ora sono solo i valori predefiniti dei numeri. (Lezione: assegna un nome ai predicati di supporto con attenzione.)

• Il comportamento che stavo tentando di implementare che ho incasinato era in realtà una soluzione alternativa per un bug leggermente diverso. Puoi leggere l'intera terribile storia qui: https://docs.microsoft.com/en-us/archive/blogs/ericlippert/the-root-of-all-evil-part-one e https://docs.microsoft .com / en-us / archive / blogs / ericlippert / the-root-of-all-evil-part-two (Lezione: è molto facile introdurre nuovi bug peggiori mentre si risolvono quelli vecchi.)

• Il team di C # ha deciso di sancire questo comportamento bug piuttosto che risolverlo perché il rischio di rompere il codice esistente senza alcun vantaggio convincente era troppo alto. (Lezione: fallo bene la prima volta!)

• Il codice che ho scritto in Roslyn per preservare questo comportamento può essere trovato nel metodo IsConstantNumericZeroin https://github.com/dotnet/roslyn/blob/master/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/ConversionsBase.cs - guardalo per maggiori dettagli su cosa sia esattamente il comportamento di Roslyn. Ho scritto quasi tutto il codice nella directory Conversions; Ti incoraggio a leggere tutto perché ci sono molti fatti interessanti su come C # diverge dalle specifiche nei commenti. Ho decorato ciascuno con SPEC VIOLATION per renderli facili da trovare.

Un altro punto di interesse: C # consente anche di utilizzare qualsiasi valore enum in un inizializzatore enum indipendentemente dalla sua zeroness:

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

Le specifiche sono alquanto vaghe sul fatto che questo debba essere legale o meno, ma ancora una volta, poiché questo è stato nel compilatore da molto tempo, è probabile che i nuovi compilatori mantengano il comportamento.

Le enumerazioni in C # sono per definizione valori integrali. Per coerenza, il C # non dovrebbe accettare nessuna di queste assegnazioni, ma 0.0viene silenziosamente considerato come integrale 0. Questo è probabilmente un residuo di C, dove il letterale è 0stato trattato in modo speciale e potrebbe essenzialmente prendere qualsiasi tipo dato: intero, numero in virgola mobile, puntatore nullo ... lo chiami.

enum è davvero inteso (in tutte le lingue che lo supportano) come un modo per lavorare con stringhe significative e univoche (etichette) piuttosto che con valori numerici. Pertanto, nel tuo esempio, dovresti usare Bar e Baz solo quando hai a che fare con un tipo di dati enumerato Foo . Non dovresti mai usare (confrontare o assegnare) un numero intero, anche se molti compilatori ti permetteranno di farla franca (le enumerazioni sono solitamente numeri interi internamente), e in questo caso, uno 0,0 viene trattato con noncuranza come 0 dal compilatore.

Concettualmente, dovrebbe essere corretto aggiungere un intero n a un valore enumerato, per ottenere n valori più in basso sulla riga, o prendere val2 - val1 per vedere quanto sono distanti, ma a meno che la specifica del linguaggio non lo consenta esplicitamente, io Lo eviterei. (Pensa a un valore enumerato come se fosse come un puntatore C, nei modi in cui puoi usarlo.) Non c'è motivo per cui le enumerazioni non possano essere implementate con numeri in virgola mobile e un incremento fisso tra di loro, ma non ne ho sentito parlare questo viene fatto in qualsiasi lingua.