Procedure mit TForm1 in extra Unit?

[MCXSC]

Hallo!

Ich habe eine kurze Frage, irgendwie bin ich grade zu deppert dafür. Ich habe z.B. folgenden Aufbau:

TMainForm:

Delphi-Quellcode:

unit Mainform;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics [...];

type
  TMainFrm = class(TForm)
    [...]
  private
    [...]
  public
    [...]
  end;

var
  MainFrm: TMainFrm;  

implementation

uses UnitXYZ, [...];

{$R *.dfm}

Nun habe ich eine Unit, wie folgt:

Delphi-Quellcode:

unit UnitXYZ;

interface

procedure TuDas(NehmeDenString: String;);

implementation

uses
  MainForm [...];

procedure TuDas(NehmeDenString: String;);
begin
with MainFrm do begin
[...]
end;
end;

Die Procedure wird aus verschiedenen anderen Forms ausgeführt. Allerdings hätte ich gerne das "with MainForm do begin ... end;" weg; die gesamte Procedure soll sich eben auf "TMainForm" beziehen. Ich bekomme es nur nicht hin... :(

Kann mir jemand einen Tipp geben? Ich weiß, dass die Procedur irgendwie so aussehen muss:

Delphi-Quellcode:

procedure TMainFrm.TuDas(NehmeDenString: String;);
begin
[...]
end;

Aber ich bekomm es eben nicht zum laufen, da die Procedure ja irgendwo nochmal deklariert werden muss... :(

[mkinzler]

Übergib doch die Form als Parameter

[Sir Rufo]

Hi,

versuch es doch mal mit

Delphi-Quellcode:

with MainFrm do

cu

Oliver

[MCXSC]

Zitat:

Zitat von mkinzler

Übergib doch die Form als Parameter

Hm?

Zitat:

Zitat von Sir Rufo

Hi,

versuch es doch mal mit

Delphi-Quellcode:

with MainFrm do

Danke, aber so sieht es ja bisher aus. Ich würde das aber gerne etwas kompakter bauen.

[Sir Rufo]

Ich wollte nur damit sagen, dass das so nicht funktioniert, bzw. so definiert überflüssig ist ...

Zitat:

Zitat von MCXSC

Delphi-Quellcode:

unit Mainform;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics [...];

type
  TMainFrm = class(TForm)
    [...]
  private
    [...]
  public
    [...]
  end;

var
  MainFrm: TMainFrm;  

implementation

uses UnitXYZ, [...];

{$R *.dfm}

Delphi-Quellcode:

unit UnitXYZ;

interface

procedure TuDas(NehmeDenString: String;);

implementation

uses
  MainForm [...];

procedure TuDas(NehmeDenString: String;);
begin
with MainForm do begin  /// <<< Das tut aber so nicht !!!!! Hmmm, tut eigentlich schon, ist aber Quatsch ...
[...]
end;
end;

[MCXSC]

Doch tut es. ;)

Delphi-Quellcode:

with MainFrm do

...lässt nur eine Codezeile zu, die sich auf's MainForm bezieht...

Delphi-Quellcode:

with MainFrm do begin [...] end;

...bezieht sich auf den gesamten Block zwischen begin und end... ;)

Ich weiß, es ist sinnfrei, eine gesamte Procedure so "einzumauern", aber genau das versuche ich ja grade zu lösen^^

[Sir Rufo]

Zitat:

Zitat von MCXSC

Doch tut es. ;)

Hab es grad geeditet :mrgreen:

[Sir Rufo]

Zitat:

Zitat von MCXSC

Die Procedure wird aus verschiedenen anderen Forms ausgeführt. Allerdings hätte ich gerne das "with MainForm do begin ... end;" weg; die gesamte Procedure soll sich eben auf "TMainForm" beziehen. Ich bekomme es nur nicht hin... :(

So wie du das deklariert hast bezieht sich alles auf die UNIT MainForm aber nicht auf das FORMULAR MainFrm!!!

Was ist denn der tiefere Sinn dafür?

Entweder ich habe ein proc oder func, die direkt mit einem Formular verknüpft ist, dann nehme ich die in die Klasse direkt mit auf, oder die ist generisch, dann meinetwegen in eine eigene Unit und dann das Formular als Parameter mit.

Und trotzdem wirst du dann mit with ... do arbeiten werden wollen (nicht müssen).

cu

Oliver

[MCXSC]

Zitat:

Zitat von Sir Rufo

So wie du das deklariert hast bezieht sich alles auf die UNIT MainForm aber nicht auf das FORMULAR MainFrm!!!

Was ist denn der tiefere Sinn dafür?

Kleinerer Fehler. MainForm = MainFrm. Hab mich beim schnellen tipseln der Procedure halt vertippt.

Zitat:

Zitat von Sir Rufo

Entweder ich habe ein proc oder func, die direkt mit einem Formular verknüpft ist, dann nehme ich die in die Klasse direkt mit auf, oder die ist generisch, dann meinetwegen in eine eigene Unit und dann das Formular als Parameter mit.

Genau das versuche ich doch... o_O

Wenn ich eine eigene Funktion direkt in MainForm eingebe, reicht es, wenn ich die Procedure nochmals im "private" deklariere. *denk*

[Die Muhkuh]

Ja, reicht.

[MCXSC]

Zitat:

Zitat von Die Muhkuh

Ja, reicht.

Nur das die Funktion eben in einer anderen Unit steht. ;) (Bitte lesen :()

[Die Muhkuh]

Achso, Du willst eine Methode von MainForm (in Mainform.pas) in Unit2.pas reinstecken? Das geht nicht. :zwinker:

[MCXSC]

Ja, wie gesagt: Ich habe in der Unit "UnitXYZ" eben eine Procedure. Zum Bleistift:

Delphi-Quellcode:

procedure TuDies(NehmeString: String);
begin
with MainFrm do begin
Button1.Caption := NehmeString;
Label1.Caption := NehmeString;
Caption:= NehmeString;
end;
end;

Wie man sieht, beziehen sich alle Befehle in der Prozedur auf Komponenten/Dinge aus der Unit MainForm (bzw. dem Form MainFrm). Die Procedure wird eben in den unterschiedlichsten Units aufgerufen. Bei unzähligen Prozeduren, die alle ein "with...end" enthalten, kommen da einige Zeilen zusammen.

Deswegen wollte ich eben eine Funktion basteln, die ohne den "with ... end"-Part auskommt...

[Die Muhkuh]

Das geht nur, wenn Du die Procedure zur Methode der Klasse machst und damit muss es wieder in der Unit von der MainForm stehen.

[Sir Rufo]

Wie schon gesagt,

wenn du für dein Formular - und zwar aussschließlich für dieses Formular und niemals ein anderes Formular - eine function oder procedure haben möchtest, dann gehören die in die Klassendefinition dieses einen Formulars und damit auch in die gleiche Unit wie dieses selbige oben genannte Formular.

Als kleine Frage:

Warum möchte man so etwas denn trennen?

[Dunkel]

Delphi-Quellcode:

procedure TuDies(NehmeString: String);
begin
MainFrm.Button1.Caption := NehmeString;
MainFrm.Label1.Caption := NehmeString;
MainFrm.Caption:= NehmeString;
end;

...und schon hast Du 2 Zeilen gespart, aber trotzdem mehr getippt.

Das was Du möchtest, geht nicht mit Delphi.

[Sir Rufo]

Zitat:

Zitat von Dunkel

Das was Du möchtest, geht nicht mit Delphi.

Warum sollte das auch gehen?

Ist irgendwie für nix gut ...

cu

Oliver

[MCXSC]

Zitat:

Zitat von Dunkel

...und schon hast Du 2 Zeilen gespart, aber trotzdem mehr getippt.

Darum ja auch bisher "with ... end". ;)

Zitat:

Zitat von Sir Rufo

Warum möchte man so etwas denn trennen?

Weil ich dann eine bessere Struktur reinbekomme. Zum Beispiel eine Funktion "UnitDatenbank", in der nur Funktionen/Przeduren sind, die sich rund um "die" Datenbank drehen (z.B. Löschen, Erstellen, Öffnen...) und so weiter.

Ich habe recht viele Funktionen, die sich auf Komponenten auf dem Hauptform beziehen - alle mit unterschiedlichen Aufgaben"gebieten". Darum eben diese Auslagerung - 50++ Prozeduren und Funktionen in einer Unit sind eben etwas unübersichtlich. ;)

[Sir Rufo]

Zitat:

Zitat von MCXSC

Weil ich dann eine bessere Struktur reinbekomme. Zum Beispiel eine Funktion "UnitDatenbank", in der nur Funktionen/Przeduren sind, die sich rund um "die" Datenbank drehen (z.B. Löschen, Erstellen, Öffnen...) und so weiter.

ähhhhh .... ja ....

Ein Programm gliedert sich wie folgt
- Eingabe (interaktiv mit dem User)
- Verarbeitung (gedaddel mit den schönen Platten, etc.)
- Ausgabe (wieder mit dem User)

Eingabe und Ausgabe ist die Aufgabe der Forms
Verarbeitung eine Sache von Units (s. z.B. DatenModul in Delphi)

cu

Oliver

[Die Muhkuh]

Hmm, Logik sollte sowieso von der Oberfläche getrennt werden und nicht eine Trennung nach Funktion.

[Matze]

Zitat:

Zitat von MCXSC

[...] in der nur Funktionen/Przeduren sind, die sich rund um "die" Datenbank drehen (z.B. Löschen, Erstellen, Öffnen...) und so weiter.

Das sind Dinge, die gehören eigentlich in eine eigenständige Klasse und sollten mit der VCL nichts zu tun haben. Die eingelesenen Daten des Benutzers kannst du dann an die Methoden der Datenbank-Klasse übergeben und dort verarbeiten. Die Rückgabewerte kannst du dann wieder dem Benutzer präsentieren, d.h. die Ausgabe findet wieder außerhalb der Klasse statt.

Das ist mal das verdeutlicht, was Oliver bzw. Manu geschrieben haben.

[MCXSC]

Zitat:

Zitat von Matze

Das sind Dinge, die gehören eigentlich in eine eigenständige Klasse und sollten mit der VCL nichts zu tun haben. Die eingelesenen Daten des Benutzers kannst du dann an die Methoden der Datenbank-Klasse übergeben und dort verarbeiten. Die Rückgabewerte kannst du dann wieder dem Benutzer präsentieren, d.h. die Ausgabe findet wieder außerhalb der Klasse statt.

Joa, das habe ich schon verstanden. Die Sache mit der Eingabe wird ja auch so gemacht. Nur: Wie bekomme ich die Rückgabewerte wieder zurück? Dafür müsste dann ja für jede Aufgabe eine zweite Procedur im jeweiligen Form her?

[Sir Rufo]

Zitat:

Zitat von MCXSC

Nur: Wie bekomme ich die Rückgabewerte wieder zurück? Dafür müsste dann ja für jede Aufgabe eine zweite Procedur im jeweiligen Form her?

Mit einer entsprechende Schnittstelle:

Delphi-Quellcode:

funtion TuWasUndGibEsZurück( var Daten : TDaten ) : boolean;
begin
  {Hier tue ich was mit den Daten}
end;

oder meinetwegen

Delphi-Quellcode:

funtion TuWasUndGibEsZurück( Daten : TDaten; var Ergebnis : TErgebnis ) : boolean;
begin
  {Hier tue ich was mit den Daten und pack das in Ergebnis}
end;

oder

Delphi-Quellcode:

funtion TuWasUndGibEsZurück( var Daten : TDaten ) : TErgebnis;
begin
  {Hier tue ich was mit den Daten und dann}
  RESULT := { das Ergebnis zurückliefern }
end;

cu

Oliver

[MCXSC]

Nur damit verdreifacht (oder noch mehr) sich ja die Anzahl der Funktionen... Wenn ich z.B. Name, Vorname und PLZ auslesen will, muss ich ja a) für jedes Feld eine Function schreiben und b) für jedes Feld die Funktion gesondert aufrufen...

[Sir Rufo]

ja, oder du schreibst eine entsprechende Klasse:

Delphi-Quellcode:

TDaten = record
  Vorname : string;
  Nachname : string;
  PLZ : string;
  Ort : string;
end;

und die lässt du dir zurückgeben.

Wie ich schon sagte, mit entsprechenden und _geeigneten_ Schnittstellen

cu

Oliver