Geerbter Getter für lokale Objekt-Konstante?

[Uwe Raabe]

Ich kann zwar immer noch nicht ganz überblicken, was du da nun brauchst bzw. willst, aber ich hätte hier einen etwas anderen Ansatz (hab nur leider gerade kein XE5 zur Hand):

Delphi-Quellcode:

UNIT Unit_1;

Interface

uses
  System.Rtti;

type
  FuncInfoAttribute = class(TCustomAttribute)
  private
    FGL: string;
    Fn_Var: Integer;
  public
    constructor Create(AGL: string; An_Var: Integer);
    property GL: string read FGL;
    property n_Var: Integer read Fn_Var;
  end;

type
  TRttiHelper = record
  public
    class function FindAttribute<T: TCustomAttribute>(Source: TClass): T; overload; static;
    class function FindAttribute<T: TCustomAttribute>(Source: TRttiObject): T; overload; static;
  end;

//------------------------------------------------------------------------------------
Type
  [FuncInfo('Funktion mit ZWEI Variablen', 2)]
  TFunk_2 = Class(TObject)
  Strict Private
    function GetGL: String;
    Function Get_n_var: Integer;
  Public
    property GL: String read GetGL;
    Property n_Var: Integer Read Get_n_var;
  End;
  //------------------------------------------------------------------------------------

Type
  [FuncInfo('Funktion mit DREI Variablen', 3)]
  TFunk_3 = Class(TFunk_2)
  End;

  //------------------------------------------------------------------------------------

Implementation

function TFunk_2.GetGL: String;
var
  attr: FuncInfoAttribute;
begin
  attr := TRttiHelper.FindAttribute<FuncInfoAttribute>(ClassType);
  Result := attr.GL;
end;

Function TFunk_2.Get_n_var: Integer;
var
  attr: FuncInfoAttribute;
begin
  attr := TRttiHelper.FindAttribute<FuncInfoAttribute>(ClassType);
  Result := attr.n_Var;
End;


constructor FuncInfoAttribute.Create(AGL: string; An_Var: Integer);
begin
  FGL := AGL;
  Fn_Var := An_Var;
end;

class function TRttiHelper.FindAttribute<T>(Source: TClass): T;
var
  context: TRttiContext;
  myType: TRttiType;
begin
  Result := nil;
  context := TRttiContext.Create;
  myType := context.GetType(Source);
  if myType <> nil then begin
    Result := FindAttribute<T>(myType);
  end;
end;

class function TRttiHelper.FindAttribute<T>(Source: TRttiObject): T;
var
  attr: TCustomAttribute;
  attributes: TArray<TCustomAttribute>;
begin
  Result := nil;
  attributes := Source.GetAttributes;
  for attr in attributes do begin
    if attr is T then begin
      Result := T(attr);
      Break;
    end;
  end;
end;

Initialization
  TRttiContext.KeepContext;

Finalization
  TRttiContext.DropContext;

End.

[Andreas13]

@Uwe Raabe: Danke Uwe!!! Das ist die high sophisticated Lösung eines wirklichen Master Developers!
Da ich bisher weder mit Rtti noch mit der Klasse TCustomAttribute zu tun hatte, muss ich mich zuerst in die Materie einlesen. Im Buch von Marco Cantu: Object Pascal Handbook (2015) habe ich eine recht verständliche Einführung gefunden.
Leider läßt sich Dein Delphi 10.4 Sydney – Code mit meinem XE5 nicht kompilieren. An folgenden drei Stellen rebelliert mein Compiler:

Delphi-Quellcode:

1): Implementation: class function TRttiHelper.FindAttribute<T>(Source: TRttiObject): T;
-->  TRttiHelper.FindAttribute<T> ist rot unterstrichen

2): Initialization: TRttiContext.KeepContext;
-->  KeepContext ist rot unterstrichen

3): Finalization: TRttiContext.DropContext;
-->  DropContext ist rot unterstrichen

Vielleicht kennt jemand eine Abhilfe für Delphi XE5?
Danke & Gruß, Andreas

[himitsu]

Hmmm, technisch sollte es auch schon mindestens im XE(1) gehen.
Es kann aber sein, dass : TCustomAttribute auch in der Implementation angegeben sein muss/musste.
Und KeepContext/DropContext gab es früher nicht ... dein Teil kannst einfach weglassen. (dann wird erst im TRttiContext.Create jedes mal der Context neu erstellt)

Und ob Man nun via RTTI ein [Attribut] oder die Konstante ausliest, macht eigentlich keinen Unterschied, ABER
* man muß aufpassen dass die Konstante nicht wegoptimiert wird (wenn sie nicht "direkt" benutzt wird)
* und dass man die privaten Teile der Klasse nicht aus der RTTI entfernt hat
http://docwiki.embarcadero.com/RADSt...ctive_(Delphi)

[Uwe Raabe]

Dann lass den TRTTIHelper ganz weg und mach das direkt in dem FuncInfoAttribute:

Delphi-Quellcode:

type
  FuncInfoAttribute = class(TCustomAttribute)
  private
    FGL: string;
    Fn_Var: Integer;
  public
    constructor Create(AGL: string; An_Var: Integer);
    class function FindAttribute(Source: TClass): FuncInfoAttribute;
    property GL: string read FGL;
    property n_Var: Integer read Fn_Var;
  end;

class function FuncInfoAttribute.FindAttribute(Source: TClass): FuncInfoAttribute;
var
  context: TRttiContext;
  myType: TRttiType;
  attr: TCustomAttribute;
  attributes: TArray<TCustomAttribute>;
begin
  Result := nil;
  context := TRttiContext.Create;
  myType := context.GetType(Source);
  if myType <> nil then begin
    attributes := myType.GetAttributes;
    for attr in attributes do begin
      if attr is FuncInfoAttribute then begin
        Result := FuncInfoAttribute(attr);
        Break;
      end;
    end;
  end;
end;

In den Gettern musst du dann die FindAttribute-Zeile so schreiben:

Delphi-Quellcode:

  attr := FuncInfoAttribute.FindAttribute(ClassType);

[Andreas13]

Vielen-vielen Dank Himitsu und Uwe!!!
Ich habe die beiden Zeilen TRttiContext.KeepContext; und TRttiContext.DropContext; auskommentiert. Auch Uwe’s neue Class Function habe ich eingebaut. So läßt sich alles kompilieren und es funktioniert korrekt!! Danke!

Noch zwei kurze Fragen bitte:
In der Klassen-Methode class function FuncInfoAttribute.FindAttribute(Source: TClass): FuncInfoAttribute; wird das Object mit context := TRttiContext.Create; erzeugt. Sollte ich evtl. noch context.Free einfügen, weil ich TRttiContext.DropContext; auskommentieren mußte? Wäre hier evtl. ein Speicherschutzblock try .. finally notwendig? Oder ist es bei Klassenmethoden nicht erforderlich?
Danke Euch allen & viele Grüße, Andreas

[himitsu]

Das ist ein Record, kein Objekt.

Intern liegen Interfaces, welche automatisch freigegeben werden.
Und bei gemangten Variablen hat Delphi heimlich ein Try-Finally in der Funktion versteckt. (quasi im BEGIN und END davon, für Interfaces, Strings, DynArrays usw.)

[Andreas13]

Ihr führt mir immer wieder den Unterschied zwischen einem Amateur (= mir) und den Profis (= IHR) vor Augen. Habe stets viel von Euch gelernt: Danke!
Gruß, Andreas