Trennung von GUI und Logik, wie geht ihr vor?

[divBy0]

Hallo zusammen,

in diversen Themen hier taucht ja immer wieder die Trennung von GUI und Logik auf. Mich würde es mal interessieren wie ihr dabei vor geht.

Beispiel:

Ein Formular mit zwei Edits, einem Button und einem Label.

Delphi-Quellcode:

unit uMain;

interface

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

type
  TForm1 = class(TForm)
    EditZahl1: TEdit;
    EditZahl2: TEdit;
    ButtonAddition: TButton;
    LabelErgebnis: TLabel;
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

end.

Eine Klasse mit einer "extrem schwierigen" Berechnung:

Delphi-Quellcode:

unit uAddition;

interface

type
  TAddition = class
    private
      FErgebnis: Integer;
    public
      function Addition(Zahl1, Zahl2: Integer): Integer;
      property Ergebnis: Integer read FErgebnis;
  end;

implementation

{ TAddition }

function TAddition.Addition(Zahl1, Zahl2: Integer): Integer;
begin
  FErgebnis := Zahl1 + Zahl2;
  Result := FErgebnis;
end;

end.

Vielen Dank schon mal für euer Mitmachen!

[Stevie]

Meine Klasse sähe so aus:

Delphi-Quellcode:

type
  TAddition = class
  private
    FErgebnis: Integer;
  public
    procedure Addition;
    property Zahl1: Integer read FZahl1 write FZahl1;
    property Zahl2: Integer read FZahl2 write FZahl2;
    property Ergebnis: Integer read FErgebnis;
  end;

und dann würde ich die Properties an die Edits und das Label binden und die Methode an den Button

[divBy0]

Ok, damit sieht dein ButtonOnClick so aus oder?

Delphi-Quellcode:

procedure TForm1.ButtonAdditionClick(Sender: TObject);
begin
  FAddition.Zahl1 := StrToIntDef(EditZahl1.Text, 0);
  FAddition.Zahl2 := StrToIntDef(EditZahl2.Text, 0);
  FAddition.Addition;
  LabelErgebnis.Caption := IntToStr(FAddition.Ergebnis);
end;

Dies sollte doch eigentlich auch vermieden werden, wegen Spaghetticode.

[Phoenix]

Zitat von divBy0:

Ok, damit sieht dein ButtonOnClick so aus oder?

Delphi-Quellcode:

procedure TForm1.ButtonAdditionClick(Sender: TObject);
begin
  FAddition.Zahl1 := StrToIntDef(EditZahl1.Text, 0);
  FAddition.Zahl2 := StrToIntDef(EditZahl2.Text, 0);
  FAddition.Addition;
  LabelErgebnis.Caption := IntToStr(FAddition.Ergebnis);
end;

Dies sollte doch eigentlich auch vermieden werden, wegen Spaghetticode.

Nein, das sollte deshalb vermieden werden, weil das Form um himmels willen niemals im Leben nicht die Klasse TAddition kennen darf.

Es geht ja gerade darum, die Logik vom GUI zu trennen. Deswegen darf die GUI die Logik nicht kennen. Und die Logik das GUI auch nicht.

Dazwischen muss etwas geschaltet werden, das als Vermittler agiert. Also z.B. klassisches MVC: Model (Logik), View (Form), Controller (kennt beides), der Controller fehlt hier komplett und wäre dann das, was die Logik-Klasse mit ihren Properties an die ein- bzw. Ausgabefelder am Form und die Ausführung der Methode an deren Button event bindet.

[SebE]

Ich mache das immer der Art:

Delphi-Quellcode:

type
  TAdditionVisualComponent = class
    public:
      procedure resultChangeEvent(result: integer); virtual; abstract;
    end;

type
  TAddition = class
    [...]

    private:
      visualComponent: TAdditionVisualComponent;
    end;

// ---

function TAddition.Addition(Zahl1, Zahl2: Integer): Integer;
begin
[...]

if self.visualComponent <> nil then
  self.visualComponent.resultChangeEvent(Zahl1 + Zahl2);
end;

Konkrete Implementation der visuellen Repräsentation im Presenter/in der View (ich verwende eine abgewandelte Form des MVC):

Delphi-Quellcode:

type
  TAdditionVC = class(TAdditionVisualComponent);
  public:
    procedure resultChangeEvent(result: integer); override;
  end;

// ---

procedure TAdditionVC.resultChangeEvent(result: integer);
begin
  Form1.Edit1.Text = IntToStr(result);
end;

Der Aufruf des ganzen erfolgt aus der GUI über den Controller (falls vorhanden zuvor über den Presenter):
MyController.Add(StrToInt(Edit2.Text), StrToInt(Edit3.Text)); Jetzt kommt es darauf an, wie man den Controller mit den Business-Objekten verbinden möchte.
Der einfachste Fall (der Controller kennt nur ein Objekt):

Delphi-Quellcode:

type
  Controller = class;
    private:
      MyAddition: TAddition;
  end;

// ---

procedure Controller.Add(Zahl1, Zahl2: integer);
begin
  MyAddition.Addition(Zahl1, Zahl2);
end;
MyAddition

Das ist das, was ich aus dem Stehgreif auf die Schnelle zusammentragen kann.

[Stevie]

Zitat von SebE:

Konkrete Implementation der visuellen Repräsentation im Presenter/in der View (ich verwende eine abgewandelte Form des MVC)

Mich persönlich hat bei dem MVC/MVP Modell immer gestört, dass man für meinen Geschmack zu viel Code erzeugt und trotzdem noch statische Abhängigkeiten hat

Das ist auch ansatzweise an deinem Beispiel sichtbar.

[Luckie]

Zitat von Phoenix:

Zitat von divBy0:

Ok, damit sieht dein ButtonOnClick so aus oder?

Delphi-Quellcode:

procedure TForm1.ButtonAdditionClick(Sender: TObject);
begin
  FAddition.Zahl1 := StrToIntDef(EditZahl1.Text, 0);
  FAddition.Zahl2 := StrToIntDef(EditZahl2.Text, 0);
  FAddition.Addition;
  LabelErgebnis.Caption := IntToStr(FAddition.Ergebnis);
end;

Dies sollte doch eigentlich auch vermieden werden, wegen Spaghetticode.

Nein, das sollte deshalb vermieden werden, weil das Form um himmels willen niemals im Leben nicht die Klasse TAddition kennen darf.

So würde ich das aber auch lösen. Wie sähe denn deine Lösung aus?

[SebE]

Zitat von Luckie:

Zitat von Phoenix:

Zitat von divBy0:

Ok, damit sieht dein ButtonOnClick so aus oder?

Delphi-Quellcode:

procedure TForm1.ButtonAdditionClick(Sender: TObject);
begin
  FAddition.Zahl1 := StrToIntDef(EditZahl1.Text, 0);
  FAddition.Zahl2 := StrToIntDef(EditZahl2.Text, 0);
  FAddition.Addition;
  LabelErgebnis.Caption := IntToStr(FAddition.Ergebnis);
end;

Dies sollte doch eigentlich auch vermieden werden, wegen Spaghetticode.

Nein, das sollte deshalb vermieden werden, weil das Form um himmels willen niemals im Leben nicht die Klasse TAddition kennen darf.

So würde ich das aber auch lösen. Wie sähe denn deine Lösung aus?

(fett durch mich)
Dann hast du aber die Aufgabe nicht gelöst, um die es hier geht.

Allgemein:
Eine saubere Trennung erreicht man nur durch Abstraktion. Dass diese Mehraufwand beim Schreiben verursacht, sollte hier nicht das Thema sein.

[Neumann]

Für diesen einfachen Fall zu umständlich.

Delphi-Quellcode:

type
   TAddition = class
   private
     
   public
     function Add(wert1,wert2:integer; var Ergebnis:integer):boolean;
     
   end;
Implemaentation

Function Taddition.Add;
begin
  Ergebnis:=wert1+wert2;
  result:=(wert1<>0) and (wert2<>0);
end;

Result zeigt dann ob was sinnloses gemacht wurde oder kann auf einen Konvertierungsfehler hinweisen.

Die Sache mit privaten Feldern, Methoden sowie Properties macht nur dann Sinn, wenn man Werte zwischenspeichen will.

[Stevie]

Zitat von divBy0:

Ok, damit sieht dein ButtonOnClick so aus oder?

Delphi-Quellcode:

procedure TForm1.ButtonAdditionClick(Sender: TObject);
begin
  FAddition.Zahl1 := StrToIntDef(EditZahl1.Text, 0);
  FAddition.Zahl2 := StrToIntDef(EditZahl2.Text, 0);
  FAddition.Addition;
  LabelErgebnis.Caption := IntToStr(FAddition.Ergebnis);
end;

Dies sollte doch eigentlich auch vermieden werden, wegen Spaghetticode.

Zitat von Stevie:

und dann würde ich die Properties an die Edits und das Label binden und die Methode an den Button

Das Verb binden bezieht sich in diesem Satz auch auf "die Methode an den Button"

Somit entsteht in dem Form 0 Code. Es gibt nur ca 4 Zeilen externen Wire up Code.