Procedure Problem

[Neutral General]

Delphi-Quellcode:

 Proc = procedure;

 TGenericList = class(TObjectList)
  private
   FType: TClass;
   FAdd: Proc;
  public
   property AddObj: Proc read FAdd;
   constructor Create(ObjType: TClass);
 end;

 TProcedures = class
  published
   procedure AddTLabel(ALabel: TLabel);
   procedure AddTButton(AButton: TButton);
 end;

procedure TProcedures.AddTLabel(ALabel: TLabel);
begin
  ShowMessage('AddTLabel!');
end;

procedure TProcedures.AddTButton(AButton: TButton);
begin
   ShowMessage('AddTButton!');
end;

constructor TGenericList.Create(ObjType: TClass);
begin
  FType := ObjType;
  FAdd  := TProcedures.MethodAddress('Add' + ObjType.ClassName);
end;

Das geht soweit ja aber ich will halt wenn ich AddObj aufrufe die Parameter sehn die die Procedure hat und dann halt so das ich wenn ich

TGenericList.Create(TLabel) aufrufe auch nur Labels hinzufügen kann in meine liste...

also das dann wenn man AGenericList. schreibt das Menü aufploppt und man halt nur die Procedure AddObj(ALabel: TLabel) zur Auswahl hat.. wenn bei im OnCreate TButton angegeben hat dann halt AddObj(AButton: TButton)

[DGL-luke]

Hmm... ja, das wirst du nur mit templates schaffen. Hab mich da übrigens heute schon sehr intensiv damit beschäftgigt und auch über das nachgedacht, was du gerade versuchst.

Das einzige was da noch "sauber" möglich ist, ist eine Abfrage im Add:

if (item is FType) then
FList.Add()
else
raise EDingsbums.Create('falsche klasse');

dagegen sollte es eigentlcih möglcih sein... hmm... nee... mehr geht nicht. Wie bereits gesagt, templates. Codelib -> typisierte liste

[negaH]

Das geht schon mit Delphi

Delphi-Quellcode:

procedure A(const Params: array of const);
begin
end;

// Aufruf dann

begin
  A([1]);
  A([1, 'String', #32, nil, TMyObject.Create]);
end;

Gruß Hagen

[DGL-luke]

wow... tatsächlich... daran hab ich gar nicht gedacht.

Allerdings hilft das beim konkreten problem nicht weiter, man kann eine runtime-typenentscheidung nicht designtime-typesicher machen... :gruebel:

[negaH]

Zitat:

man kann eine runtime-typenentscheidung nicht designtime-typesicher machen...

DAS, musst du mir nochmal in anderen Worten hin schreiben, ansonsten kapiere ich nicht was du damit meinst ;)

Gruß Hagen

[negaH]

Übrigens geht auch

Delphi-Quellcode:

procedure A(const Params: array of Variant);
begin
end;

Gruß Hagen

[DGL-luke]

Ähm.. ich habe das gefühl, NeutralGeneral will eine typensichere Liste machen. Mit voller IDE-Unterstützung, so dass der Compiler schon meckert wenn man den falschen Typ in die Liste wirft. Allerdings soll dieser Typ eben über FType: TClass determiniert werden - zur Laufzeit.

Und das - designtime-typsicherheit, wenn der typ zur runtime gesichert wird - geht wohl nicht.

Was ist denn der Unterschied zwischen array of const und array of variant?

[negaH]

Der Unterschied definiert sich aus der unterschiedlichen Deklaration eines Array Types. Einmal ein array of const, was nichts anderes ist als ein array of TVarRec -> TVarRec in System.pas nachschauen, und eben dem Typen Variant.

Gruß Hagen

[negaH]

Zitat:

Ähm.. ich habe das gefühl, NeutralGeneral will eine typensichere Liste machen. Mit voller IDE-Unterstützung, so dass der Compiler schon meckert wenn man den falschen Typ in die Liste wirft. Allerdings soll dieser Typ eben über FType: TClass determiniert werden - zur Laufzeit.

Das nenne ich Datenbank-Komponnete. Verschiedene Klassen vom Basistyp TField definieren die Datenschnittstelle samt Typen für einen Record in der Datenbank. Die Datenbank selber steht in einer TTabel/TQuery und enthält eine Liste von Typsicheren TField's.
Die Datenbank ist unser Listen-Objekt das die Daten Typensicher ausnehmen kann.

Per IDE zur Designzeit kann man einerseits diese TTable/TQuery/TDataSet frei definieren und dann zusäzlich noch gleich mit Daten füllen.


Gruß Hagen