Procedure Problem

[Neutral General]

Hi,

Ich hätte da ein Probleeem. Also ich habe eine Variable A

Delphi-Quellcode:

var A: TProcedure;

und angenommen

Delphi-Quellcode:

A = procedure Test(Abc: Integer);

Ich habe dann eine Klasse die soll dann eine Procedure enthalten die so aussieht wie die aus A. Versteht ihr was ich meine ?
Wie mach ich das ?

Gruß
Neutral General

[DGL-luke]

öhm.... so?

Delphi-Quellcode:

type
  TMyProc = procedure(param: Integer) of object;

  TMyClass = class
    procedure SomeProc(param: Integer);
  end;

var
  Proc: TMyProc;

Proc := TMyClass(nil).SomeProc; //das funzt jetzt natürlich nicht^^

[Neutral General]

Naja ich erklärs nochmal anders:

Delphi-Quellcode:

type
 TKlasse = class(Egal)
  private
   A: TProcedure;
  public
   constructor Create(...); override;
   procedure A; // Da soll dann die Procedure stehn die im Konstruktor zugewisen wurde...
 end;


constructor Create(...);
begin
 inherited Create(...);
 A:= *Irgendwas* // Aber oft verschieden
 ...
end;

[Der_Unwissende]

Na an sich war doch der Ansatz von DGL-Luke gar nicht so falsch.

Delphi-Quellcode:

type
  TMyProc = procedure(int : Integer) of object;

  TMyProcInvoker = class(TObject)
    public
      procedure doFoo(int : Integer);
  end;

  TMyClass = class(TObject)
    public 
      mp : TMyProc;
  end;

implementation

procedure TMyClass.FormCreate(Sender: TObject);
var buffer : TMyProcInvoker;
begin
  buffer := TMyProcInvoker.Create;
  self.mp := buffer.doFoo;
end;

[edit]
ein end vergessen!
[/edit]

[Neutral General]

Also das Problem das die Procedure ja mal so aussehn kann:

Delphi-Quellcode:

procedure Ka1(Bla: Integer);

und ein anderes mal

Delphi-Quellcode:

procedure Hallo(S: String; Abc5: Pointer);

und dann will ich:

Delphi-Quellcode:

var Test: TMyClass;

procedure TForm1.OnCreate(Sender: TObject); 
begin
 Test := TMyClass.Create;
 Test.Procedure(50); // wenn Procedure = Ka1 ist
 Test.Procedure('Test',@Form1); // wenn Procedure = Hallo ist
end;

:mrgreen:

[DGL-luke]

NEIN, das geht auf gar keinen fall.

Allerdings gibt es dafür overload...


Nuja...

Delphi-Quellcode:

type
  TZweigProc = procedure of object;

  TMyAbZweig = class
    public
      SprungInsUngewisse: TZweigProc;
      contructor Create;
    private
      procedure A;
      procedure B;
      procedure C;
    end;

implementation

procedure TMyAbZweig.Create;
begin
  if RandSeed = 0 then Randomize;

  case Random(3) of
    0: SprungInsUngewisse := A;
    1: SprungInsUngewisse := B;
    2: SprungInsUngewisse := C;
  end;
end;

procedure TMyAbzweig.A;
begin
  ShowMessage('A');
end;

procedure TMyAbzweig.B;
begin
  ShowMessage('B');
end;

procedure TMyAbzweig.B;
begin
  ShowMessage('B');
end;

Un jetzt bitte sehr erzeugen und SprungInsUngewisse aufrufen:

Delphi-Quellcode:

with TMyAbZweig.Create do
  SprungInsUngewisse;

Kannst du damit was anfangen?

[Neutral General]

nein leider nicht weil meine Proceduren immer Parameter haben und sie auch im Quelltext wenn man z.B in deinem Beispiel Sprunginsungewisse aufruft erkennen muss welche es ist und auch entsprechend Parameter angeben können soll.. aber das geht glaub ich schon von der Logik her nicht.. der Compiler kann ja nicht vorher wissen was nachher zugewiesen wird...naja eventuell schon bei mir aber so schlau ist der leider nicht -.-^^

[DGL-luke]

ähm...

Delphi-Quellcode:

procedure a(s: string); overload;
procedure a(s: string; x: Integer); overload;
procedure a(x: Integer; p: Pointer); overload;

Delphi-Quellcode:

a('blubb',4); //jetzt wird die zweite funktion aufgerufen

Das ist so ungefähr die Funktionsweise von overload.

Zitat:

nein leider nicht weil meine Proceduren immer Parameter haben

Delphi-Quellcode:

type
  TIntToBool = function(param: Integer): Boolean;

So besser?

[Neutral General]

ne :mrgreen:

Ich versuche ja gerade Overload zu vermeiden.. Wenn ich overload benutze ist mein ganzes vorhaben schwachsinnig :mrgreen:

[DGL-luke]

:roll:

Dann erklär uns halt dein Vorhaben...

[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