Auf Methoden einer Form zugreifen die über TFormClass erzeug

[Sharky]

Hai,

ich "spiele" eben etas mit TFormClass.
Meine Forms (TForm2 und TForm3) haben beide eine Methode .SetLabelText. Gibt es eine andere Möglichkeit auf diese von meiner Form1 zugreifen zu können als wie so:

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
var
  newFormClass : TFormClass;
  newForm : TForm;
begin
  Case (Sender AS TButton).Tag of
    0 : newFormClass := TForm2;
    1 : newFormClass := TForm3;
  end;
  newForm := newFormClass.Create(self);
  try
    if (newFormClass = TForm2) then
    begin
      (newForm as TForm2).SetLabelText('Form 2');
    end
    else
    begin
      (newForm as TForm3).SetLabelText('Form 3');
    end;

    //  newForm.SetLabelText ('*blubb das geht nicht*');

    newForm.ShowModal;
  finally
    FreeAndNil (newForm);
  end;
end;

Das Projekt hänge ich mal an.

[shmia]

Zitat von Sharky:

ich "spiele" eben etas mit TFormClass.
Meine Forms (TForm2 und TForm3) haben beide eine Methode .SetLabelText. Gibt es eine andere Möglichkeit auf diese von meiner Form1 zugreifen zu können als wie so:

1.) die Methode muss im published sein. Normalerweise werden nur Properties und Event published gemacht.
2.) die Methode wird dynamisch mit Hilfe von RTTI aufgerufen:

Delphi-Quellcode:

type
   // alle SetLabelText Methoden müssen diese Signatur haben
   TMySpecialMethode = procedure(const data:string) of object;

   procedure CallMySpecialProc(comp: TComponent; const data:string);
   var
      m: TMySpecialMethode;
   begin
      TMethod(m).Data := comp;
      TMethod(m).Code := comp.MethodAddress('SetLabelText');

      if( TMethod(m).Code <> nil )then
      begin
        m(data);  // der Aufruf
      end
      else
      begin
         LogMsg('CallMySpecialProc - %s (%s) has no SetLabelText procedure',[comp.Name,comp.ClassName]);
      end;
   end;

Alternativ kann man auch mit Interfaces arbeiten, da sich damit eine Art von Mehrfachvererbung erreichen lässt.

[choose]

Hallo Sharky,

erstelle ein Interface mit den benötigten Methoden, die Du von beiden voneinander unabhängigen Klassen erwartest und sprich die Exeplare über eben dieses an.

EDIT: Namen geändert

[Bernhard Geyer]

Oder definiere eine Zwischenformularklasse:

Delphi-Quellcode:

type
  TBaseForm = class(TForm)
  public
    procedure SetLabelText; virtual; abstract;
  end;

  TForm2 = class(TBaseForm)
  public
    procedure SetLabelText; override;
  end;

  TForm3 = class(TBaseForm)
  public
    procedure SetLabelText; override;
  end;

und in deiner Funktion
  newForm: TBaseForm;

[Sharky]

Zitat von shmia:

1.) die Methode muss im published sein. Normalerweise werden nur Properties und Event published gemacht.

Hai shmia,
dei Methode war nur ein Beispiel. Bei einem Propertie habe ich ja genau das selbe Problem. Ich werde mir deinen Vorschlag mal ansehen.
Mit Interfaces habe ich noch nicht gearbeitet. Wäre also ein guter Grund mich damit zu beschäftigen

Zitat von choose:

Hallo sakura,

*sich umguckt* Wo ist denn die DP-Katze in diesem Thread

@Bernhard:
Auch deinen Vorschlag werde ich mir ansehen.

[jim_raynor]

Ich glaube, dass der Beste weg über den gemeinsamen Vorfahren ist, wobei die Variante über die RTTI natürlich nett ist Wobei es Probleme gibt, wenn sich dort die Parameter ändern. Dann dürftest du mit AV beglückt werden, wenn du nicht dran denkst, die Aufrufe anzupassen. Auf den Prüfen, den Compiler, muss man da leider verzichten.
Interfaces ist auch ne nette Lösung, läuft aber auf das gleiche wie den gemeinsamen Vorfahren hinaus.

[Sharky]

Zitat von Bernhard Geyer:

...
und in deiner Funktion
  newForm: TBaseForm;

Hai Bernhard,

ich habe das jetzt mal versucht allerdings kommt in dieser Zeile:
newForm := newFormClass.Create(Self); die Meldung:

Zitat:

Inkompatible Typen: 'TBaseForm' und 'TForm'

[Bernhard Geyer]

Dann definiere noch:

Delphi-Quellcode:

type
  TBaseFormClass = class(TBaseForm);

var
  newFormClass : TBaseFormClass;

[choose]

Hallo Sharky,

vielleicht ist meine Ausführung etwas zu knapp gewesen. Die Lösung über RTTI ist fehlerträchtig, weil nicht Typsicher. Die Lösung mit der Vererbungshierarchie zwingt Dich zur Einhaltung einer Linie, die nicht unbedingt gewollt ist, wenn Du über Fabriken Exemplare von Klassen erzeugst, die von einander unabhängig sein können- wie in Deinem Beispiel.
Der Ansatz über Typpürfungen ist deshalb unelegant, weil Du an jeder Stelle an der Du mit unterschiedlichen Klassen arbeitest über jede Klasse prüfen müsstest.

Deshalb mein Vorschlag, Interfaces, hier zB:

Delphi-Quellcode:

type
  IMyInterface = Interface
  ['{70EA899F-F97B-4F8E-9C9E-1C3EF3718EE7}']
    procedure SetLabelText(const AText: string);
  end;

zu verwenden und die Deklaration Deiner Formulare entsprechend zu erweitern

Delphi-Quellcode:

type
  TForm2 = class(TForm, IMyInterface)
  protected
    procedure SetLabelText(const AText: string);

der Code innerhalb des Buttons könnte dann so aussehen:

Delphi-Quellcode:

[..]
  newForm := newFormClass.Create(self);
  try
    //ohne Wissen der konkreten Klasse kann die Methode über
    //das Interface verwendet werden
    if newForm.GetInterface(IMyInterface, myRef) then
      myRef.SetLabelText('AText');

    newForm.ShowModal;
  finally
    FreeAndNil (newForm);
  end;

Vielleicht hilft Dir in diesem Zusammenhang auch das factory pattern oder, zur Vermeidung von Interfaces das visitor pattern der GoF weiter.

[Sharky]

Zitat von Bernhard Geyer:

Dann definiere noch:...

Heute scheint nicht mein Tag zu sein

Jetzt bekomme ich hier:
newFormClass := TForm2;

Zitat:

Inkompatible Typen: 'TBaseFormClass' und 'Class reference'

Ich hänge den jetzigen Stand des TestProjektes noch einaml an.