Programmcode aufteilen auf mehrere Units

[hans-peter]

Erst mal guten Tag, und habt Verständnis für meine Einsteigerfrage.

Ich hab mal irgendwo gelesen, daß man zu lange Programmcodes in Units aufteilen soll, wegen der Übersichtlichkeit.
Nur krieg ichs trotz vieler Versuche nicht hin.

Ich habe ein Formuar (Form1), die dazugehörende Unit1, und eine Unit2 ohne Formular.

Frage 1 : Funktioniert das nur mit funktionen oder proceduren? Will heißen, wenn ich mit

{dieser Teil steht in Unit1}
case verlauf of
1:
2:
3:

zum Beispiel die

4:
5:
6:
7:

auf die zweite, zusätzliche Unit verlagern will, würde das auch funktionieren? Oder eben doch nur mit functionen und proceduren?


Und die Frage 2: Wenn überhaupt was funktioniert, welche Eintragungen gehören in Unit1 und Unit2 unter interface und implementation?
Wenn nämlich das nur mit proceduren funktioniert, und ich müßte die dann in Unit1 anmelden, dann brauch ich die Unit2 nicht mehr?

Kann das jemand beantworten und begreiflich machen?

Auf jeden Fall schon mal Danke.

Hans-Peter

[Phoenix]

Soweit ich weiss, kannst Du eine einzelne Methode nicht auf zwei Dateien aufteilen.

Im Regelfall mache ich eine Aufteilung so:

Klassendefinition: (In MeineKlassen.pas)

Delphi-Quellcode:

   MyClass1 = class(TObject)
      private
      protected
         procedure MyProcedure;
      public
          constructor Create; override;
   end;

   MyClass2 = class(MyClass1)
      private
      protected
         procedure MyProcedure; Override;
      public
          constructor Create; override;
   end;


implementation

uses Blafasel;

//--------------------------------------------------------------------------
// In den folgenden Dateien ($I für Include) sind die oben definierten Objekte implementiert:
//--------------------------------------------------------------------------
{$I MyClass1.pas}
{$I MyClass2.pas}

Implementation 1: (In MyClass1.pas)

Delphi-Quellcode:

// Constructor
constructor MyClass1.Create;
begin
   inherited;
   // Code
end;

procedure MyClass1.MyProcedure;
begin
   // Code
end;

Implementation 2: (In MyClass2.pas)

Delphi-Quellcode:

// Constructor
constructor MyClass2.Create;
begin
   inherited;
   // Code
end;

procedure MyClass2.MyProcedure; Override;
begin
   // Code
end;

[edit=Daniel B]Delphi-Tags ergänzt. MfG Daniel B.[/edit]

[Hellcat]

Hallo Hans-Peter!

Damit das mit den Units funktioniert musst Du die verwendeten Units mit den ausgelagerten Funktionen/Prozeduren auf der Unit, die darauf zugreifen soll deklarieren. Wenn von Unit1 benötigte Funktionen oder Prozeduren auf Unit2 liegen muss das so aussehen:

Delphi-Quellcode:

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, Unit2;
[...]//Hier kommen die Objektdeklarationen hin

implementation
{$R *.dfm}

//Hier steht der Quelltext den die Unit1 enthält

Solltest Du jetzt aber auch auf der Unit2 auf Unit 1 verweisen wollen muss das ganze so aussehen:

Delphi-Quellcode:

unit UnitLS;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls, ExtCtrls;

implementation

uses Unit1;

Hoffe Dir damit weiter geholfen zu haben.

MFG

Hellcat

[wo0zy]

Zitat:

Zitat von hans-peter2

{dieser Teil steht in Unit1}
case verlauf of
1:
2:
3:

zum Beispiel die

4:
5:
6:
7:

auf die zweite, zusätzliche Unit verlagern will, würde das auch funktionieren? Oder eben doch nur mit functionen und proceduren?

das wird nicht so recht gehen, da du bei einem "normalen" delphi-programm ja eh nur units schreibst arbeitest du da auch nur mit proceduren und funktionen. wenn du jetzt meinst das ein teil der procedure hier und ein anderer teil da sein soll, dann kannste das nich einfach da raus kopieren oder so, sondern du musst dir dann halt neue proceduren schreiben die du dann in auch in einzelne units auslagern kannst. diese units bindest du dann ganz einfach per uses ein und schwupps fertig. es gibt sogar einen menüpunkt units verwenden, da kannste dann deine units zu deinem programm hinzufügen.
ob es sinnvoll ist eine case anweisung in einzelne units zu verlagern wage ich zu bezweifeln außer das sind tausend zeilen code :wink:.
aber jeder wie ers am besten kann...

//EDIT: das hauptaugenmekr liegt in der möglichkeit der wiederverwendbarkeit der einzelnen funktionen und proceduren, und ein riesenvorteil gegenüber der dll, die unit wird mit compiliert was bedeutet das du sie deinem compilierten programm nicht anhängen musst, das sie in die exe eingebunden ist. units sind allerdings nicht kompatibel zu anderen programmiersprachen so wie dll's es sind

[Christian Seehase]

Moin Hans-Peter,

eine Aufteilung ergibt sich oft schon dadurch, dass man mehr als ein Formular hat.
In eigene Units auslagern sollte man Funktionen/Prozeduren/Variablen/Konstanten, die entweder für verschiedene Programme nützlich sind, so dass man nicht immer wieder alles neu schreiben muss, oder die im Programm öfter gebraucht werden, bzw. die von verschiedenen Units gebraucht werden. Am besten fasst man dabei logisch zusammenhängende Dinge in einer Unit zusammen.

Unter interface muss alles stehen, was von anderen Units aus erreichbar sein soll. Unter implementation kommen dann die eigentlichen Funktionen/Prozeduren, die im interface veröffentlicht wurden, sowie alle übrige, was innerhalb der unit gebraucht wird.

Von den beiden möglichen uses Abschnitten (unter interface bzw. implementation) hat es sich als günstig erwiesen, nach Möglichkeit den unter implementation zu verwenden, da dies die Gefahr von Zirkelbezügen zwischen Units verringert. Das ist allerdings auch Geschmackssache.

Ansonsten kann ich Dir nur empfehlen Dich auch mal bei Gelegenheit mit dem objektorientierten Ansatz zu befassen, so dass logisch zusammenhängendes nicht nur in units, sondern in Objekten zusammengefasst werden kann.

Dies nur mal so als kurzer Abriss, der keinen Anspruch auf Vollständigkeit erhebt ;-)

[hans-peter]

Herzlichen Dank!
Viel Neues für einen Anfänger.
Die Antwort von Hellcat hat meine Frage am Besten getroffen.
Danke.
Hans-Peter