Programmteile in extra Unit auslagern

[padavan]

Hallo Leute, habe eine Frage bzgl. Unit - Einbindung.

Ich bin dabei ein Programm zu schreiben, bei dem vom Hauptformular aus auch noch weitere Formulare zur Laufzeit erzeugt werden können und Parameter zwischen diesen Fenstern übergeben werden. So weit so gut, das geht auch.
ABER:
Ich habe es bisher nicht geschafft, einen Programmteil in eine Unit ohne Formular auszulagern. (Der Sinn und Zweck einen Programmteil auszulagern soll einfach darin liegen, dass ich Quelltext aus dem Hauptunit rausbekomme um Übersicht im Programm zu schaffen.)
Ich scheitere aber immer daran, dass in der ausgelagerten Unit die Komponenten des Hauptformulars und/oder auch die Variablen des Hauptformulars nicht definiert sind.
Also hab ich mir versucht in der OH anzuschauen, wo und wie ich die Variablen deklarieren muss, damit das "gesamte Programm" die Variablen kennt. Da stolpert man über den Interface Abschnitt oder über den Public Abschnitt.

Habe
1. die Unit_extern in der Uses-Klausel in der Unit1 eingebunden
2. die Unit1 in der Unit_extern eingebunden
3. Variablen die Global sein sollen in Unit1 unter Public deklariert

Trotzdem geht´s net. :wall:

[jfheins]

Delphi-Quellcode:

Unit.Variablenname

oder

Delphi-Quellcode:

Form.Variablenname

... :zwinker:

[kalmi01]

Hi

Delphi-Quellcode:

unit uMain;
{$I myDebug.pas}

  interface
    uses
      Windows, Messages, Dialogs, SysUtils, Forms, StdCtrls, Classes, Controls, ExtCtrls,
      StShlCtl, SRChkBox, ovcbase, ovcmeter, LEDPaint, dynForm;

    type
      TMain = class(TForm)
......
    end;

    var
      Main        : TMain;
      SavCursor   : TCursor;

  implementation
    {$R *.dfm}

    uses
      uUtil;   <=== das brauchst Du !!!

Dann Aufruf z.B.:

Delphi-Quellcode:

uUtil.Demo := true;

uUtil.machwas(SavCursor);

Willst Du in der ausgelagerten Unit auf Variablen von Main zugreifen, musst Du entweder die Main-Unit in der ausgelagerten als "uses" deklarieren, oder mit

Delphi-Quellcode:

procedure test (var value : irgendwas);

arbeiten und die Werte "public" übergeben und zurückholen.

[roderich]

Hi padavan,

wenn du Quellcode aus einer Formular-Unit in eine Extra-Unit auslagerst, dort aber wieder auf Formular-Komponenten aus der ersten Unit zugreifen mußt......dann stimmt irgendwas mit deinem Konzept nicht. Übersichtlicher wird dadurch gar nichts und du bekommst auch noch zirkuläre Referenzen (was zwar compilierbar ist, solange nicht in beiden Units im Interface, aber unsauber). Außerdem ist es dann mit sauberer Objektorientierung vorbei, sobald du nämlich mehr als eine Instanz deines Formulars hast, geht das Ganze in die Hose.

Stattdessen würde ich in die Extra-Unit nur allgemeine Routinen auslagern und entsprechend Variablen im Prozedurkopf deklarieren.

also statt

Delphi-Quellcode:

procedure DoIt;
begin
  MyMainForm.ListBox.Add(.....);
end;

lieber

Delphi-Quellcode:

procedure DoIt(aListBox: TListBox);
begin
  aListBox.Add(.....);
end;

Roderich

[DymonD]

Wenn du nur Funktionen/Prozeduren hast, dann kanst du die doch einfach in eine Unit auslagern, die bindest du dann hier ein:

Delphi-Quellcode:

interface 
    uses 
      Windows, Messages, ..., DeineUnit;

Vorteil: Du kannst aber auch häufig verwendete Funktionen da mit einbinden, die du normalerweise selbst immer neu hättest coden müssen ;-)

[padavan]

Hallo Roderich,

naja, es ging mir eigentlich darum Quellcode aus der Hauptform rauszunehmen, nicht aus zusätzlichen Formularen, die sind ja dann schon extra und "sauber", allerdings triffts DymonD recht gut mit seinem Vorschlag. Genauso in der Art hätte ich mir das vorgestellt. Eine Procedure welche sehr Textintensiv ist einfach aus der Unit1 rausnehmen --> aus übersichtlichkeit eben.
Diese Variante werde ich gleich mal versuchen umzusetzten...

Vielen Dank für jede Hilfe!!!

[padavan]

Hmm, muss noch mal nerven,

habe jetzt die Procedure in eine andere Unit ausgelagert

Delphi-Quellcode:

unit Unit_Sprache;

interface

implementation


var Variablename: integer;
begin

//  Anweisung......

end;

end.

und diese Unit folgendermaßen deklariert

Delphi-Quellcode:

interface


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

Aber wie spreche ich nun diese procedure in der ausgelagerten Unit an?
Habe es mit Unit_Sprache.? "und genau das hängts schon" versucht. :gruebel:

Bin für jede Hilfe dankbar.

Padavan

[DymonD]

Du musst das wie jede "normale" Prozedur auch deklarieren:

Delphi-Quellcode:

procedure Addiere(zahl1, zahl2: integer): integer;
begin
  // Mache was...
end;

Das Ganze aufrufen dann mit

Delphi-Quellcode:

c := Addiere(a, b);

Eigentlich einfach :mrgreen:
Das ist ja in dem Moment genauso, wie

Delphi-Quellcode:

StrToInt(Edit2.Text);

Diese Prozedur ist ja nicht anders definiert ;-)

[schöni]

Delphi-Quellcode:

unit Unit_Sprache; 

interface 

implementation 


var Variablename: integer; 
begin 

//  Anweisung...... 

end; 

end.

Zwischen der Variablenvereinbarung "Variablenname" und dem "Begin End" muß "procedure" stehen,
so hier:

Delphi-Quellcode:

var Variablename: integer; 
PROCEDURE DeineProzedur;
begin 

//  Anweisung...... 
  Variablenname := 1;

end;

schöni

[padavan]

So langsam bin ich depremiert, scheinbar habe ich noch irgendwie ein Verständnisproblem.

Wenn ich die "externe" Unit in die Unit1 einbinde (und das habe ich jeweils im Interface sowohl als auch im Implementation Abschnitt versucht), dann bin ich trotzdem nicht in der Lage, eine Procedure in der "externen" Unit aufzurufen.


Habe die Korrektur von schöni auch schon mit drin.

Dennoch meckert Delphi beim Übersetzen, da es die Procedure von der externen Unit in der Unit1 nicht kennt. Die Variablen aus der Unit1 sind allerdings in der externen Unit bekannt, das klappt wenigstens schonmal.

Was allerdings auch nocht nicht funktioniert ist, wenn ich in der externen Unit auf Komponenten des Hauptformulars zugreifen will, dass er diese dann auch wieder nicht kennt. :gruebel:

[jim_raynor]

Der Prozedurkopf muss auch im Interface-Teil der Unit stehen:

Delphi-Quellcode:

unit Unit_Sprache; 

interface 

function Addiere(a,b: Integer): Integer;

implementation 


var Variablename: integer; 

function Addiere(a,b: Integer): Integer;
begin 
  result:=a+b;
end; 

end.

Nur was im Interface-Teil drin steht, kann auch von aussen genutzt werden. Alles andere ist nur in der Unit verfügbar.

[Sharky]

Hai padavan,

hier mal der Code für ein Formular und eine externe Unit (Unit2). Das sollte die depresion verhindern ;-)

Delphi-Quellcode:

unit Unit2;

interface
  // Hier werden die Funktionen nach aussen bekannt gemacht
  function AddZahlen (value1, value2 : Real) : Real;
  procedure MacheEtwas (var ergebniss : Real ; value1, value2 : String);

implementation

uses SysUtils;


function AddZahlen (value1,value2 : Real) : Real;
begin
  result := value1 + value2;
end;

procedure MacheEtwas (var ergebniss : Real ; value1, value2 : String);
var
  r1,
  r2 : Real;
begin
  r1 := StrToFloat(value1);
  r2 := StrToFloat(value2);
  ergebniss := r1 + r2;
end;

end.

Delphi-Quellcode:

unit Unit1;

interface

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

type
  TForm1 = class(TForm)
    Button1: TButton;
    Button2: TButton;
    procedure Button1Click(Sender: TObject);
    procedure Button2Click(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation

uses
 Unit2;  // Unit mit den Funktionen einbinden

{$R *.dfm}

procedure TForm1.Button1Click(Sender: TObject);
var
  test1 : Real;
begin
  test1 :=  AddZahlen(45.2,6.6);
  ShowMessage (FloatToStr (test1));
end;

procedure TForm1.Button2Click(Sender: TObject);
var
  test2 : Real;
begin
  MacheEtwas(test2,'45,2','6,6');
  ShowMessage (FloatToStr (test2));
end;

end.

[Edit] :cry:
Jetzt habe ich so schön getippelt und jim_raynor war schneller.

[padavan]

He Sharky, :hi:

trotzdem war´s nicht umsonst, den ein Delphi-Padavan wie ich ist froh über jede Info....!!!

kennt ihr das: man glaubt man hat es und freut sich wie ein Kind und dann......die Ernüchterung.
Denn: dank eurer Hilfe kann ich jetzt die Procedure in der "externen" Unit ansprechen,
ABER: in dieser Procedure ist es nicht möglich an die Form1 zu gelangen:

Delphi-Quellcode:

procedure test;
var Variable: integer;
begin
  Form1.height := 200; //Beispiel
end;

bei Form1. gibt´s gemecker von Delphi, da er die Form1 nicht kennt.
Nun hab ich versucht die Unit1 bei Uses der externen Unit einzubinden, hat aber nicht geholfen.

Es gab die Meldung, "Unit1.dcu nicht gefunden" :wiejetzt:

[Sharky]

Hai padavan,

trage die Unit1 mal nach implementation in der Unit2 ein.

Delphi-Quellcode:

Unit Unit2;
.
.
implementation 
Uses Unit1;
.
.

[himitsu]

Eine ganz "brutale Methode ist {$INCLUDE ...}

Damit kann man einen Teil der Unit direkt in eine andere Datei auslagern. (damit ist es sogar Möglich Teile, die sonst nicht auslagerbar sind, dennoch auszulagern)
Ich hab da ein Programm, mit einigen hundert Ereignisprozeduren, welche ja so nicht auslagerungsfähig sind - aber damit ging es dennoch und ich hatte auch etwas mehr übersicht.

Und da so der ausgelagerte Teil dennoch Teil der Unit ist, gibt es auch keine Probleme mit Veriablen ...

Delphi-Quellcode:

// Unit1.pas

unit Unit1;

interface

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

type
  TForm1 = class(TForm)
    Button1: TButton;
    Button2: TButton;
    procedure Button1Click(Sender: TObject);
    procedure Button2Click(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

{$INCLUDE UnitX.inc}

end.

Delphi-Quellcode:

// UnitX.inc

procedure TForm1.Button1Click(Sender: TObject);
begin
  ...
end;

procedure TForm1.Button2Click(Sender: TObject);
begin
  ...
end;

[padavan]

Zitat:

trage die Unit1 mal nach implementation in der Unit2 ein.

Daraufhin kam ja die Fehlermeldung ja erst:

Delphi-Quellcode:

unit Unit_Sprache;

interface

procedure Sprachzuweisung1;

implementation
uses Unit1;   //  Fehler Unit1.dcu nicht gefunden

procedure......

Die Idee von himitsu ist auch interessant werde ich auch mal bei Gelegenheit probieren, allerdings würde ich´s gern erstmal auf "normalem" Wege hinbekommen, da ich die Zusammenhänge noch nicht ganz verinnerlicht habe... :oops:

[himitsu]

Klar, der "normale" Weg ist besser, voallem weil man da ja eine "richtige" Unit erhällt, während bei include nur Teile in 'ner Datei rumliegen :)

[padavan]

Ach mann, da hab ich mir am Schluss noch selbst ein Ei gelegt, Sharky hatte natürlich recht: Einfach die Unit1 in den Implementation Abschnitt rein und dann funzt´s.

Also nochmal vielen Dank an alle
Padavan
:witch: