Ich arbeite schon lange mit record helpern für alle möglichen Typen. Auch für Enum benutze ich record helper und die funktionieren sehr gut.

Ich stoße bei Enum allerdings auf ein Problem mit impliziter Zuweisung.

Hier ein Codebeispiel, der mir sogar von der "RAD AI Companion" vorgeschlagen wurde.

zusammenfalten · markieren

Delphi-Quellcode:

type
  TColor = (rot, grün, blau);

  TColorHelper = record helper for TColor
    class operator Implicit(a: TColor): string;
    class operator Implicit(a: string): TColor;
  end;

class operator TColorHelper.Implicit(a: TColor): string;
begin
  case a of
    rot: Result := 'rot';
    grün: Result := 'grün';
    blau: Result := 'blau';
  else
    Result := 'unbekannt';
  end;
end;

class operator TColorHelper.Implicit(a: string): TColor;
begin
  if a = 'rot' then
    Result := rot
  else if a = 'grün' then
    Result := grün
  else if a = 'blau' then
    Result := blau
  else
    raise Exception.Create('Ungültiger Farbname');
end;

var
  lFarbe: string;
  color: TColor;
begin
  color := rot;
  lFarbe := color; // implizite Konvertierung von TColor zu string -> [dcc32 Fehler] Test.dpr(49): E2010 Inkompatible Typen: 'TColor' und 'string'
  WriteLn(lFarbe); // Ausgabe: rot

  lFarbe := 'grün';
  color := lFarbe; // implizite Konvertierung von string zu TColor -> [dcc32 Fehler] Test.dpr(53): E2010 Inkompatible Typen: 'string' und 'TColor'
  WriteLn(Ord(color)); // Ausgabe: 1 (Ordinalwert von grün)
end.

Habe ich irgendetwas übersehen? Compilerschalter? Fehlender Uses-Eintrag?

Nenn das Ding mal probehalber nicht TColor.

Umbenannt. Immer noch der Fehler.

Operator overloading wird in Helpern nicht unterstützt: Helper Syntax

Zitat:

Class and record helpers do not support operator overloading.

man stelle sich mal vor, der Compiler würde einem Sagen, wenn er was ignoriert.

Zitat von Uwe Raabe:

Operator overloading wird in Helpern nicht unterstützt:

Folgendes compiliert und funktioniert. Da ist auch der class operator im Helper. Verstecktes feature

zusammenfalten · markieren

Delphi-Quellcode:

type
  TTestRecord = record
    value:Integer;
    end;

  TTestRecordHelper = record helper for TTestRecord
    class operator Implicit(a: TTestRecord): string;
    class operator Implicit(a: string): TTestRecord;
    class operator Implicit(a: TTestRecord): Integer;
    class operator Implicit(a: Integer): TTestRecord;
  end;

class operator TTestRecordHelper.Implicit(a: TTestRecord): string;
begin
  Result := inttostr(a.value);
end;

class operator TTestRecordHelper.Implicit(a: string): TTestRecord;
begin
  Result.value := strtoint(a);
end;

class operator TTestRecordHelper.Implicit(a: Integer): TTestRecord;
begin
  Result.value := a;
end;

class operator TTestRecordHelper.Implicit(a: TTestRecord): Integer;
begin
 Result := a.value;
end;

var
  lTestRecord:TTestRecord;
  lString:string;
  lInteger:Integer;
begin
  lTestRecord := 1;
  lString := lTestRecord;
  WriteLn(lString);

  lTestRecord := '2';
  lInteger := lTestRecord;
  WriteLn(inttostr(lInteger));

  Readln;
end.

Das ist ja wirklich super, dass dies funktioniert, aber soll ich das jetzt nutzen oder besser nicht
Wie steht Embarcadero denn dazu?

Die Implicit-Überladung scheint für Records zu funktionieren, für Enums aber nicht.
Enums werden in Delphi intern als Integer behandelt, das behandelt der Compiler womöglich nicht als Record.