Warum sind Operationen zwischen verschiedenen Enum-Typen in einer anderen Enum-Deklaration zulässig, aber nicht anderswo?

Question

Die C# Compiler ermöglichen Operationen zwischen verschiedenen Aufzählungstypen in einer anderen Aufzählungstyp Erklärung, wie folgt aus:

public enum VerticalAnchors 
{ 
    Top=1, 
    Mid=2, 
    Bot=4 
} 

public enum HorizontalAnchors 
{ 
    Lef=8, 
    Mid=16, 
    Rig=32 
} 

public enum VisualAnchors 
{ 
    TopLef = VerticalAnchors.Top | HorizontalAnchors.Lef, 
    TopMid = VerticalAnchors.Top | HorizontalAnchors.Mid, 
    TopRig = VerticalAnchors.Top | HorizontalAnchors.Rig, 
    MidLef = VerticalAnchors.Mid | HorizontalAnchors.Lef, 
    MidMid = VerticalAnchors.Mid | HorizontalAnchors.Mid, 
    MidRig = VerticalAnchors.Mid | HorizontalAnchors.Rig, 
    BotLef = VerticalAnchors.Bot | HorizontalAnchors.Lef, 
    BotMid = VerticalAnchors.Bot | HorizontalAnchors.Mid, 
    BotRig = VerticalAnchors.Bot | HorizontalAnchors.Rig 
} 

aber verbietet sie innerhalb Methodencode, dh die Operation:

VerticalAnchors.Top | HorizontalAnchors.Lef; 

mit diesem Fehler gekennzeichnet ist :

Operator '|' cannot be applied to operands of type 'VerticalAnchors' and 'HorizontalAnchors'.

Es gibt eine Abhilfe, natürlich:

Ich bin neugierig auf dieses Compiler-Verhalten. Warum sind Operationen zwischen verschiedenen Aufzählungstypen in einer anderen Aufzählung zulässig, aber nicht anderswo?

Answer 1

Es ist eigentlich nicht in der spec, soweit ich das beurteilen kann. Es ist etwas im Zusammenhang:

If the declaration of the enum member has a constant-expression initializer, the value of that constant expression, implicitly converted to the underlying type of the enum, is the associated value of the enum member.

Obwohl VerticalAnchors.Top & HorizontalAnchors.LefVerticalAnchors hat Typ kann es implizit in VisualAnchors umgewandelt werden. Dies erklärt jedoch nicht, warum der konstante Ausdruck selbst implizite Konvertierungen überall unterstützt.

Eigentlich scheint es ausdrücklich gegen die Spezifikation zu sein:

The compile-time evaluation of constant expressions uses the same rules as run-time evaluation of non-constant expressions, except that where run-time evaluation would have thrown an exception, compile-time evaluation causes a compile-time error to occur.

Wenn ich nicht etwas übersehen haben, die Spezifikation nicht nur nicht dies ausdrücklich nicht erlaubt, es es nicht zulässt. Unter dieser Annahme wäre es ein Compilerfehler.

Answer 2

C# ermöglicht die Definition von Enum-Werten, die einen konstanten Wert enthalten, so dass ein Enum-Wert eine Kombination von Enumerationen sein kann, z. [Flags]. Der Compiler berechnet jeden Enum-Wert im Ausdruck als int (normalerweise), so dass Sie bitweise und arithmetische Operationen für den Enum-Wert ausführen können.

Außerhalb einer Aufzählungsdefinition müssen Sie die Aufzählung in einen primitiven Typ konvertieren, bevor Sie eine Operation ausführen.

Answer 3

Interessant. Sie können auch fragen, warum dies erlaubt ist:

enum MyType 
{ 
    Member = DayOfWeek.Thursday | StringComparison.CurrentCultureIgnoreCase, 
} 

wenn diese nicht erlaubt ist:

var local = DayOfWeek.Thursday | StringComparison.CurrentCultureIgnoreCase; 

Der Grund, dass in der Deklaration eines Aufzählungs zu sein scheint, in dem ENUM-Mitglied initializers, Es wird davon ausgegangen, dass jeder Enum-Wert, selbst ein Wert einer nicht verwandten Enumeration, in den zugrunde liegenden Typ umgewandelt wird. So sieht der Compiler das obige Beispiel wie folgt:

enum MyType 
{ 
    Member = (int)(DayOfWeek.Thursday) | (int)(StringComparison.CurrentCultureIgnoreCase), 
} 

Ich finde das sehr seltsam. Ich wusste, dass Sie die Werte des gleichen Enum (ohne die Umwandlung in den zugrunde liegenden Typ Angabe) direkt, wie in der letzten Zeile verwenden:

enum SomeType 
{ 
    Read = 1, 
    Write = 2, 
    ReadWrite = Read | Write, 
} 

aber ich finde es sehr überraschend, dass andere Aufzählungen 'Mitglieder werden auch in ihre zugrunde liegenden Integer-Typen umgewandelt.

Answer 4

Da Sie nicht eine Frage in Ihrer Frage haben, ich werde so tun, dass Sie einige interessante Fragen gestellt und beantwortet sie:

Is it true that inside an enum declaration, you can use values of other enums in the initializers?

Ja. Sie können

enum Fruit { Apple } 
enum Animal { Giraffe = Fruit.Apple } 

sogar sagen, wenn es nicht ohne Guss wäre legal Fruit.Apple auf eine Variable Animal Typ zuordnen.

Diese Tatsache ist gelegentlich überraschend. Tatsächlich war ich selbst überrascht. Als ich das zum ersten Mal versuchte, um einen Teil des Compilers zu testen, dachte ich, es wäre ein möglicher Fehler.

Where in the spec does it say that is legal?

Abschnitt 14.3 sagt, dass die Initialisierung eine Konstante sein muß, und daß die Konstante wird auf den zugrunde liegenden Typen der Enumeration umgewandelt werden. Aufzählungselemente sind Konstanten.

Ah, but what about this case?

enum Fruit { Apple = 1 } 
enum Shape { Square = 2 } 
enum Animal { Giraffe = Fruit.Apple | Shape.Square } 

That expression isn't a legal constant expression in the first place, so what's up?

OK, du hast mich dort. Abschnitt 14.3 sagt auch, dass Enum-Elemente in Initialisierer verwendet werden müssen nicht gegossen werden, aber es ist unklar, ob es Mitglieder der die Enum wird oder Mitglieder der Enum. Entweder ist eine vernünftige Interpretation, aber ohne spezifische Sprache ist es leicht zu denken, dass die frühere Bedeutung die beabsichtigte ist.

Dies ist somit ein bekannter Fehler; Ich habe Mads vor ein paar Jahren darauf hingewiesen und es wurde nie gelöst. Auf der einen Seite erlaubt es die Spezifikation nicht eindeutig. Auf der anderen Seite ist das Verhalten sowohl nützlich als auch im Geiste, wenn nicht vollständig im Buchstaben der Spezifikation.

Im Grunde, was die Implementierung macht, wenn es einen Enum-Initialisierer verarbeitet, behandelt es alle Enum-Mitglieder als konstante Ausdrücke ihres zugrunde liegenden Typs. (Natürlich muss es sicherstellen, dass enum-Definitionen azyklisch sind, aber das ist vielleicht besser für eine andere Frage.) Es "sieht" daher nicht, dass Fruit und Shape keinen "oder" -Operator definiert haben.

Obwohl die Spezifikation ist leider nicht klar, das ist ein wünschenswertes Merkmal. In der Tat habe ich es häufig auf dem Roslyn Team:

[Flags] enum UnaryOperatorKind { 
    Integer = 0x0001, 
    ... 
    UnaryMinus = 0x0100, 
    ... 
    IntegerMinus = Integer | UnaryMinus 
    ... } 

[Flags] enum BinaryOperatorKind { 
    ... 
    IntegerAddition = UnaryOperatorKind.Integer | Addition 
    ... } 

Es ist sehr praktisch, ist in der Lage sein, Fahnen aus verschiedenen Aufzählungen genommen zu mischen-n-Spiel.