Procedure TForm.xyz in Unit

[Noobinator]

Zitat:

Zitat von Fussball-Robby

...

Delphi-Quellcode:

Type
  TUForm = class(TForm);
  TForm = class(TUForm)
    Procedure xyz //[..]

....

hääh :gruebel:

Tuform ist von Tform abgeleitet, und Tform wieder vom Tuform?

sehe ich das jetzt richtig oder ist meine Morgenmüdigkeit noch zu massiv zum denken?

[Fussball-Robby]

Ja, du siehst das richtig, hat aber auch nen simplen Grund. Im Hauptformular ist die Form1 von TForm abgeleitet. Das heißt, die Funktionen der anderen Unit, die von dieser Form genutzt werden sollen, müssen in einer Klasse stehen, die ebenfall von TForm abgeleitet ist und dazu noch den Namen TForm haben muss. Da ich aber TForm nicht von TForm ableiten kann, mache ich es eben über TUForm.

[mkinzler]

Aber du leitest eine Klasse mit der Bezeichnung TForm wieder davon ab.

[Fussball-Robby]

Wenn ich es so belassen würde:

Delphi-Quellcode:

Type
  TUForm = class(TForm)
    Procedure xyz //[..]

Dann müsste ich in der MainUnit das Formular von TUForm ableiten. Füge ich aber die 2. Ableitung in der Unit hinzu, kann ich in der MainUnit das Formular ganz normal lassen und muss da nichts ändern.

[mkinzler]

Aber so erbt Formx nicht deine Erweiterungen.

[Fussball-Robby]

Zitat:

Zitat von mkinzler

Aber so erbt Formx nicht deine Erweiterungen.

Doch, sonst hätte ich es erst garnicht so gemacht :wink:

[Tharon]

Puuuhhh... also ich glaube, hier wird völlig aneinander vorbei geredet... und anscheinend wurde auch das eigentliche Problem gar nicht verstanden :wink:

Also... zunächst mal geht es doch darum, eine allgemein verwendbare Funktion in einer Bibliotheksunit unterzubringen. Derartige Funktionen werden nicht als Methoden (einer Klasse), sondern als ganz normale (öffentliche) Funktionen/Prozeduren implementiert:

Delphi-Quellcode:

interface

procedure xyz(s: String);


implementation

procedure xyz(s: String);
begin
  ...
end;

Das "TForm." vor dem Prozedurnamen "xyx" war also der Fehler.

Wir wissen jetzt natülrlich nicht, was diese Prozedur eigentlich tun soll... aber falls diese Prozedur etwas mit einem Formular tun soll, dann muss natürlich dieses Formular als Argument übergeben werden:

Delphi-Quellcode:

unit LibFormUtils;

uses
  Forms;


interface

procedure LibFormXYZ(a_frm: TForm; a_sText: String);


implementation

procedure LibFormXYZ(a_frm: TForm; a_sText: String);
begin
  ...
end;

Diese Prozedur kann dann mit jedem beliebigen Formular aufgerufen werden, und zwar egal von welcher Klasse dieses Formular abgeleitet ist und egal, wie dieses Formular heißt.

Der Aufruf kann so aussehen:

Delphi-Quellcode:

unit formMain;

interface

type

TfrmMain = class(TForm)
  ...
  private
    procedure XXXX;
  ...
end;

...


implementation

uses
  LibFormUtils;


procedure TfrmMain.XXXX;
begin
  ...
  LibFormXYZ(Self, 'Ein Text');
  ...
end;

Nebenbei bemerkt, muss diese Prozedur auch nicht unbedingt aus einer Methode einer Formularklasse heraus aufgerufen werden, wie in diesem Beispiel. Eine solche Funktion/Prozedur ist universell verwendbar, aus jedem beliebigen Kontext heraus (natürlich darf dann nicht "Self" als Argument übergeben werden, sondern die betreffende Formularvariable). Und darum ging es doch... eine universelle Funktion/Prozedur zu implementieren, die überall verwendbar ist :wink:

[mkinzler]

Nein er wollte Methoden der Form extern einbinden.

[Tharon]

@mkinzler:
Ich glaube, er meinte genau das, was ich beschrieben habe:

Zitat:

Hey, ich möchte mit eine Unit erstellen, in die ich alle möglichen Funktionen und Prozeduren packe. Diese Unit will ich dann unter uses eintragen, damit ich sie in meinen Projekten nutzen kann.

Eine partielle Klasse macht hier doch auch überhaupt keinen Sinn, denn das Endergebnis wäre ja genau eine Klasse, "xyz" wäre also eine Methode genau dieser einen Klasse - es soll aber doch eine allgemein verwendbare Prozedur sein. Mal abgesehen davon, dass das in Delphi sowieso nicht geht :wink:

Ein Problem kam nur dadurch zustande (und damit die ganze Diskussion), weil er fälschlicherweise (vielleicht auch nur versehentlich) "TForm1." vor den Prozedurnamen geschrieben hat - vielleicht weil er dachte, er könnte diese Prozedur sonst nicht in seinem Formular verwenden...

Falls Robby aber eigentlich die Basisklasse seiner Formulare erweitern wollte, dann muss er eine neue Klasse, die von TForm abgeleitet ist mit dieser Prozedur implementieren und seine Formulare dann von dieser neuen eigenen Basisklasse ableiten:

Delphi-Quellcode:

unit LibForm;

uses
  Forms;


type

TLibForm = class(TForm)
  ...
  procedure XYZ(a_sText: String);
  ...
end;


----------------------------------------

unit formMain;

uses
  LibForm;


type

TfrmMain = class(TLibForm)
  ...
end;

...


implementation


TfrmMain.XXXX;
begin
  ...
  XYZ('Ein Text');
  ...
end;

Aber wir sollten hier jetzt vielleicht nicht weiter darüber diskutieren, was Robby jetzt vielleicht tatsächlich gemeint haben könnte... das sollte er selbst am besten wissen und ich denke, er hat jetzt alle nötigen Infos :wink:

[mkinzler]

So ist das Problem vielleicht auch gelöst, aber doch recht umständlich, denn wenn er jede Methode händisch anpassen muss, könnte er auch gleich den Code direkt reinkoppieren.