Case-Anweisung - Zwingen alle Elemente des Typen auszuprogrammieren

[lxo]

Meine Idee mit dem Ord(High(TEnum)) war so gedacht:

Delphi-Quellcode:

type
  TEnum = ( t1, t2, t3);
var
  lEnum: TEnum;
begin
  {$DEFINE ENUMCOUNT 0}
  case lEnum of
    t1:
     begin 
      {$DEFINE ENUMCOUNT ENUMCOUNT+1}
      ...  
     end;
    t2:
     begin
      {$DEFINE ENUMCOUNT ENUMCOUNT+1}
      ... 
     end;
    // Hier immer letztes Element aus der Case-Anweisung eintragen. 
    {$IF Ord(High(TEnum)) <> ENUMCOUNT} {$MESSAGE Error 'Case-Fall fuer jedes Element ausprogrammieren!'} {$IFEND}
  else
    raise Exception.Create('Fehlermeldung');
  end;
end;

[sh17]

Zitat von himitsu:

Das ist so aber auch schwer mitzubekommen,
bzw. es wird nicht lesbarer.
{$IF Ord(High(TEnum)) <> 1} {$MESSAGE Error 'peng'} {$IFEND}

array[TEnum] of ... = (...);
Hier bekommst du die Änderung der Anzahl mit.

Wenn jemand aber gleichzeitig etwas hinzufügt und löscht,
ohne dass es zwischendrin angepasst wurde,
dann flutscht das natürlich durch.

Dann würde es aber auch knallen, weil ein alter Wert fehlt - wenn man sich bisher an seine Regel der vollständigen Auswertung gehalten hat.

[dummzeuch]

Zitat von lxo:

Zitat von dummzeuch:

Zitat von lxo:

Zitat von himitsu:

    {$IF High(TEnum) <> t2} {$MESSAGE Error 'peng'} {$IFEND}

Vielleicht ganz banal:

{$IF Ord(High(TENum) <> 1}{$MESSAGE Error 'peng'} {$IFEND}

Ist doch erstmal das gleiche wie von himitsu oder wo soll da der Unterschied sein?

Es erkennt auch, wenn jemand einen enum-Wert einfügt, nicht nur wenn jemand einen Wert anhängt. Bei beidem ändert sich Ord(High(TENum)), aber nur bei letzterem ändert sich High(TENum).

[Der schöne Günther]

Siehe auch:
Delphi merkt nicht wenn ein case-Statement vollständig ist, oder?

und

Zitat von Der schöne Günther:

Bei Sprachen wie Swift oder Rust bricht der Compiler mit einem Fehler ab, wenn ein match-Statement nicht vollständig ist. Delphi bekommt von all dem aber nichts mit(...)

[Rollo62]

Zitat von lxo:

Hätte es halt gerne direkt beim kompilieren.

Zitat von lxo:

Hallo,
ich möchte bei einer Case-Anweisung einen Compiler-Fehler bekommen ....

Genau, beim Compilieren kommt der Fehler mit so einer Lösung
CEnum : array[ TEnum ] of String = ( 't1', 't2', 't3' ); //Knallt schon hier, wenn es nicht übereinstimmt Dass man das jetzt erweitern muss, ist ja genau Sinn des Crashes.
Nebenbei hätte so eine noch weitere Vorteile, also zum Beispiel Textausgabe, Rückgabe beliebiger Werte, etc.

Eventuell sucht Du ja sowas, etwas "Verboseres":

Delphi-Quellcode:

type
  TMyEnum = (Value0, Value1, Value2);

const
  ExpectedEnumSize = 3; // Erwartete Anzahl der Elemente in TMyEnum

{$IF     Ord(High(TMyEnum)) > (ExpectedEnumSize-1) }
  {$MESSAGE ERROR 'TMyEnum wurde erweitert!'       }
{$ELSEIF Ord(High(TMyEnum)) < (ExpectedEnumSize-1) }
  {$MESSAGE ERROR 'TMyEnum wurde verkleinert!'     }
{$IFEND}

[dummzeuch]

Zitat von Rollo62:

Genau, beim Compilieren kommt der Fehler mit so einer Lösung
CEnum : array[ TEnum ] of String = ( 't1', 't2', 't3' ); //Knallt schon hier, wenn es nicht übereinstimmt

Das Problem ist, dass man dann aber die betroffenen case-Statements alle manuell raussuchen muss, was nicht ganz so einfach ist, da dort ja nicht der Typ sondern eine Variable des Typs verwendet wird, man kann also nicht einfach ein grep auf den Namen des Typs machen. Wenn der Compiler bei jedem davon einen Fehler schmeißt, ist das einfacher. Kann ja auch gerne abschaltbar sein (wobei man das ja auch mit einem else erreichen könnte).

[himitsu]

Er muß ja keinen Fehler werfen, aber z.B. eine Warnung oder Info wäre eigentlich problemlos möglich, wenn bei einem Enum nicht alle Werte benutzt wurden.

Ja, natürlich auch abschaltbar, bzw. vielleicht über ein Attribut oder Keyword, explizit anforderbar,
denn es kommt vor, dass ich in manchen Case absichtlich garnicht alles verwende,
z.B. wenn an einer Stelle nur ein Teil benötigt wird und der Rest einfach nichts machen soll.

[Uwe Raabe]

Zitat von dummzeuch:

da dort ja nicht der Typ sondern eine Variable des Typs verwendet wird, man kann also nicht einfach ein grep auf den Namen des Typs machen.

Wenn man SCOPEDENUMS verwendet, schon...