Enum in String mehrere Overloaded Funktionen zu einer einzigen zusammenfassen?

[a.def]

Folgende Funktion befindet sich in meinem Code und davon eine für jedes meiner Enums

Delphi-Quellcode:

// EnumGetString(TWProcesses.wpIdle) würde string 'wpIdle' zurückgeben
function EnumGetString(aEnumValue: TWProcesses): string;
var
 bVal: Byte;
begin
 Move(aEnumValue, bVal, SizeOf(TWProcesses));
 Result := GetEnumName(TypeInfo(TWProcesses), bVal);
end;

Ist es möglich diese Funktion so abzuändern, dass ich alle meine Enums an eine einzige Funktion schicken kann, welche mir dann den String zurückgibt wie oben zu sehen auch?

[Der schöne Günther]

Generics

http://docwiki.embarcadero.com/RADSt...BCber_Generics

[Uwe Raabe]

Zitat:

Zitat von Der schöne Günther (Beitrag 1355093)

Generics

Leider gibt es kein Constraint für Enums bei einem generischen Typ. Man verliert dabei also die Typsicherheit.

[Der schöne Günther]

Man kann den Compiler nicht zufällig anweisen keine Schlussfolgerungen über den generischen Typ anzustellen sodass der Benutzer den generischen Typ angeben muss?

Alternativ kann man, wenn einen das stört, ja einen Integer übergeben und steckt in seine "EnumZuString"-Methode dann nicht mehr "myEnum" sondern "Ord(myEnum)" rein.

[Uwe Raabe]

Zitat:

Zitat von Der schöne Günther (Beitrag 1355102)

Man kann den Compiler nicht zufällig anweisen keine Schlussfolgerungen über den generischen Typ anzustellen sodass der Benutzer den generischen Typ angeben muss?

Das habe ich jetzt nicht verstanden.

Zitat:

Zitat von Der schöne Günther (Beitrag 1355102)

Alternativ kann man, wenn einen das stört, ja einen Integer übergeben und steckt in seine "EnumZuString"-Methode dann nicht mehr "myEnum" sondern "Ord(myEnum)" rein.

Dann fehlt aber die TypeInfo, die man für GetEnumName braucht.

[Der schöne Günther]

Zitat:

Zitat von Uwe Raabe (Beitrag 1355107)

Das habe ich jetzt nicht verstanden.

Ich meine dass man sich eine generische Funktion schreibt bei welcher man den generischen Typen angeben MUSS. Dann hat man den Typen ja und kann sich seine TypInformation holen.

Für den Fall dass ein Enum nicht mehr als 128 (oder 256?) Einträge enthält ginge ja so etwas hier, aber perfekt ist das auch nicht :|. Mein Favorit ist der zweite der drei Aufrufe.

Delphi-Quellcode:

program Project16;

{$APPTYPE CONSOLE}

{$R *.res}

uses System.TypInfo;

type
   TEnum = record
      public class function GetName<T>(const enum: T): String; overload; static;
      public class function GetName<T>(const ordinalValue: System.ShortInt): String; overload; static;
   end;

{ TEnum }

class function TEnum.GetName<T>(const enum: T): String;
var
   ordinalValue: Integer;
begin
   ordinalValue := Default(Integer);
   Move(enum, ordinalValue, SizeOf(T));

   Result := GetEnumName( TypeInfo(T), ordinalValue );
end;

class function TEnum.GetName<T>(const ordinalValue: System.ShortInt): String;
begin
   Result := GetEnumName( TypeInfo(T), ordinalValue );
end;

type
   TMyEnum = (uno, dos, tres);
var
   myEnum:   TMyEnum;
begin
   myEnum := TMyEnum.dos;

   // Nicht typsicher, myEnum könnte genauso gut ein Float sein
   WriteLn( TEnum.GetName<TMyEnum>(myEnum) );

   // Typsicher, WENN man sich zwingt EXPLIZIT "TMyEnum" anzugeben
   WriteLn( TEnum.GetName<TMyEnum>(myEnum) );

   // Sieht typischer aus, aber statt myEnum könnte man ebenso gut "42" reinstecken
   WriteLn( TEnum.GetName<TMyEnum>( Ord(myEnum) ) );

   ReadLn;
end.

[Zacherl]

Zitat:

Zitat von Der schöne Günther (Beitrag 1355102)

Man kann den Compiler nicht zufällig anweisen keine Schlussfolgerungen über den generischen Typ anzustellen sodass der Benutzer den generischen Typ angeben muss?

Einen Typ angeben musst du bei einer generischen Klasse ja sowieso zwingend. Das Problem ist, dass die Delphi Generics außer

Delphi-Quellcode:

class

und

Delphi-Quellcode:

interface

keine Constraints zulassen. Wobei Constraints eh nur ein Versuch sind ein viel prägnanteres Design-Flow abzuschwächen:

Delphi-Quellcode:

class procedure TGenericClass<TEnum>.Print(Enum: TEnum);
var
  E: TEnum;
begin
  for E := Low(Enum) to High(Enum) do
  begin
    WriteLn(Ord(Enum));
  end;
end;

An dieser Stelle meldet sich der Delphi-Compiler obwohl ich die Klasse nirgends verwende mit einem Fehler, weil er einfach so davon ausgeht, dass

Delphi-Quellcode:

TEnum

kein Enum-Typ ist, sondern eine Klasse (bzw. untypisiert ist, oder was der Compiler auch immer an dieser Stelle als Standardtyp annimt). Dies ist mir relativ unverständlich, wenn ich mal mit den Templates in C++ vergleiche (diese sind auf der trivialsten Ebene praktisch Generics):

Der Code in Template-Funktionen wird erst dann verifiziert, sobald er auch generiert wird. Und generiert wird er einmalig für jeden distinkten Datentyp den ich tatsächlich irgendwo im Code an die Template-Klasse übergebe.

Delphi-Quellcode:

TGenericClass<TIrgendeinExistierendesEnum>.Print(MyEnum)

würde also ohne Probleme funktionieren, während

Delphi-Quellcode:

TGenericClass<TIrgendeineKlasse>.Print(MyClassInstance)

korrekterweise den Fehler erzeugt, dass man

Delphi-Quellcode:

Low

natürlich nicht auf einen Klassentyp anwenden darf.

Die C++ Templates sind im Gegensatz zu den Delphi Generics sozusagen Context-aware.

Am Ende kommt jedenfalls bei raus, dass man unter Delphi gezwungen wird ziemlich viele nicht typsichere Operationen durchzuführen, bei denen man höchstens mit viel Mühe und unter Verwendung der RTTI eine teilweise Typsicherheit wiederherstellen kann:
http://www.delphipraxis.net/190944-r...alisieren.html

Edit: @Günther: Und wer hindert dich bei deiner Klasse daran einfach

Delphi-Quellcode:

TEnum.GetName<TForm1>(Form1)

aufzurufen?

[a.def]

Die Antworten sind ja schon erstaunlich.
Wäre es bei so vielen Komplikationen einen schönen Code zu bekommen nicht die einfachste Möglichkeit mehrere overloaded Funktionen zu fahren?

[Zacherl]

Zitat:

Zitat von a.def (Beitrag 1355119)

Wäre es bei so vielen Komplikationen einen schönen Code zu bekommen nicht die einfachste Möglichkeit mehrere overloaded Funktionen zu fahren?

Wir wollten dich nicht verunsichern, sondern nur auf eine mögliche Gefahr hinweisen. Ich würde es trotzdem folgendermaßen lösen:

Delphi-Quellcode:

type
  TEnumHelper<TEnum> = record
    public class function GetName(Value: TEnum): String; overload; static;
  end;

{ TEnumHelper<TEnum> }

class function TEnumHelper<TEnum>.GetName(Value: TEnum): String;
var
  TypInfo: PTypeInfo;
  TypData: PTypeData;
  V: Integer;
begin
  TypInfo := TypeInfo(TEnum);
  {$IFDEF DEBUG}
  if (TypInfo^.Kind <> tkEnumeration) then
  begin
    raise Exception.Create('Invalid generic type.');
  end;
  {$ENDIF}
  TypData := GetTypeData(TypInfo);
  case TypData^.OrdType of
    otSByte,
    otUByte:
      V := PByte(@Value)^;
    otSWord,
    otUWord:
      V := PWord(@Value)^;
    otSLong,
    otULong:
      V := PInteger(@Value)^;
  end;
  Result := GetEnumName(TypeInfo(TEnum), V);
end;

Du solltest halt nur aufpassen, dass du dieser Klasse als Typ tatsächlich nur Enums übergibst und nichts anderes. Im Debug-Mode würdest du zwar im Zweifelsfalle eine Runtime-Exception bekommen, aber bei Code-Pfaden, die nicht oft ausgeführt werden, entdeckt man so einen Laufzeitfehler teilweise erst recht spät.

Alternativ müsste auch das hier gehen:

Delphi-Quellcode:

class function TEnumHelper<TEnum>.GetName(Value: TEnum): String;
var
  TypInfo: PTypeInfo;
  V: Integer;
begin
  TypInfo := TypeInfo(TEnum);
  {$IFDEF DEBUG}
  if (TypInfo^.Kind <> tkEnumeration) then
  begin
    raise Exception.Create('Invalid generic type.');
  end;
  {$ENDIF}
  case SizeOf(TEnum) of
    1: V := PByte(@Value)^;
    2: V := PWord(@Value)^;
    4: V := PInteger(@Value)^;
  end;
  Result := GetEnumName(TypeInfo(TEnum), V);
end;

[uligerhardt]

Dumme Frage: Warum nimmst du statt dem:

Zitat:

Zitat von Zacherl (Beitrag 1355123)

Delphi-Quellcode:

  {$IFDEF DEBUG}
  if (TypInfo^.Kind <> tkEnumeration) then
  begin
    raise Exception.Create('Invalid generic type.');
  end;
  {$ENDIF}

nicht einfach Assert?

Delphi-Quellcode:

  Assert(TypInfo^.Kind = tkEnumeration, 'Invalid generic type.');