OOP Umwandlung eines Testprogrammes

[NoGAD]

Hallo,

durch einige Hinweise in einem anderen Thema ( https://www.delphipraxis.net/203816-...-funktion.html) bitte ich, falls sich jemand die Zeit nehmen könnte, um das angehängte Beispiel in korrektes OOP, insbesondere die globale Variable in Unit2 betreffend, umzuschreiben.

Falls es mehrere Ansichten bezüglich der Umwandlung gibt, wäre es für mich schön, wenn statt Diskussion über einen anderen Beitrag, lieber eine neue Variante zur Verfügung gestellt würde.


LG Mathias :-)

[Luckie]

Warum sollen andere die Arbeit für dich machen? :roll:

[Medium]

Schon recht dreist, oder?

[stahli]

Finde ich nicht schlimm, Vorschläge für Verbesserungen einzuholen.

Allerdings ist mir die "Fragestellung" zu unkonkret, so dass es für mich zu aufwendig wäre, das Projekt zu überarbeiten (und Records (um die es ja wohl auch geht) ohnehin nicht mein Fall sind).

[NoGAD]

Zitat:

Zitat von Medium (Beitrag 1460858)

Schon recht dreist, oder?

Es war eine Bitte.

[stahli]

Vielleicht kannst Du Deine Frage oder Anliegen nochmal knapper fassen...

[TurboMagic]

Wie es scheint will er eine globale Variable los werden. Geht's dabei evtl. um automatisch erzeugte Forms?

[NoGAD]

Zitat:

Zitat von TurboMagic (Beitrag 1460874)

Wie es scheint will er eine globale Variable los werden. Geht's dabei evtl. um automatisch erzeugte Forms?

Nein. Es geht um eine globale Variable, die ein Record ist.

[Uwe Raabe]

Wie man das umsetzt, hängt natürlich von den konkreten Gegebenheiten ab. Daher kann man keinen allgemeinen Ansatz vorgeben.

Eine Möglichkeit die globale Variable zu eliminieren ohne den Funktionsaufruf unnötig aufzublähen wäre eine Klasse:

Delphi-Quellcode:

unit Unit2;

interface

uses
  system.StrUtils,
  system.Sysutils;

type
  TSettings = record
    Show_Errors: Boolean;
    Show_Questions: Boolean;
    Delete_Fields: Boolean;
  end;

type
  TResult = record
    String_1: string;
    String_2: string;
    initFoo_MultiUser: Boolean;
    initFoo_Done: Boolean;
    initFoo_Error: Boolean;
  end;

type
  TFooMaker = class
  private
    FSettings: TSettings;
  public
    constructor Create(const ASettings: TSettings);
    function init_FOO(const _FooFileName, _FooDatabaseName: string; _FooMultiUser: Boolean = True): TResult;
    property Settings: TSettings read FSettings;
  end;

const
  BR = #13#10;
  DBR = BR + BR;

implementation

constructor TFooMaker.Create(const ASettings: TSettings);
begin
  inherited Create;
  FSettings := ASettings;
end;

function TFooMaker.init_FOO(const _FooFileName, _FooDatabaseName: string; _FooMultiUser: Boolean = True): TResult;
var
  StringTest: string;
begin
  try
    Result.String_1 := _FooFileName;
    Result.String_2 := _FooDatabaseName;
    Result.initFoo_MultiUser := _FooMultiUser;
    Result.initFoo_Done := (Trim(_FooFileName) <> '') and (Trim(_FooDatabaseName) <> '');

    if Trim(_FooFileName) = 'EXCEPTION' then
    begin
      StringTest := '';
      StringTest := StringTest[1];
      Result.initFoo_Done := True;
    end;

    Result.initFoo_Error := False;
  except
    if Settings.Show_Errors then
      Result.initFoo_Error := True;
    Result.initFoo_Done := False;
  end;
end;

end.

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
var
  fooMaker: TFooMaker;
  myResult: TResult;
  mySettings: TSettings;
begin
  mySettings.Show_Errors := true;
  mySettings.Show_Questions := false;
  mySettings.Delete_Fields := false;

  fooMaker := TFooMaker.Create(mySettings);
  try
    myResult := fooMaker.init_FOO('Test', 'Test 1');
    Result2Memo(myResult);

    myResult := fooMaker.init_FOO('Hallo', 'Test 2', false);
    Result2Memo(myResult);

    myResult := fooMaker.init_FOO('EXCEPTION', 'Test 3', true);
    Result2Memo(myResult);

    myResult := fooMaker.init_FOO('EXCEPTION', 'Test 4', false);
    Result2Memo(myResult);
  finally
    fooMaker.Free;
  end;

  Memo1.SetFocus;
end;

[NoGAD]

Zitat:

Zitat von Uwe Raabe (Beitrag 1460888)

Wie man das umsetzt, hängt natürlich von den konkreten Gegebenheiten ab. Daher kann man keinen allgemeinen Ansatz vorgeben.

Eine Möglichkeit die globale Variable zu eliminieren ohne den Funktionsaufruf unnötig aufzublähen wäre eine Klasse:

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
var
  fooMaker: TFooMaker;
  myResult: TResult;
  mySettings: TSettings;

Danke, Uwe, für das Beispiel.
Ich verstehe es dennoch nicht. Was ist der Unterschied der drei Variablen, welche hier genutzt werden?

*TFooMaker* ist doch am Ende auch wieder ein globales Konstrukt, welches in jeder Unit verfügbar ist, welche Unit2 einbindet?

Und solange ich Unit2 nicht einbinde, wäre eine globale Variable (welche in Unit2 deklariert ist) in der jeweiligen Unit doch auch nicht sichtbar?

LG Mathias

[Uwe Raabe]

Zitat:

Zitat von NoGAD (Beitrag 1460891)

*TFooMaker* ist doch am Ende auch wieder ein globales Konstrukt, welches in jeder Unit verfügbar ist, welche Unit2 einbindet?

Die Klasse TFooMaker kann in der Tat von anderen benutzt werden. Allerdings kann jeder seine eigene Instanz erzeugen und eigene Settings verwenden. Der Instanz und den Settings in Button1Click ist das aber egal.

Ist zwar auch nur ein konstruiertes Beispiel wie der gesamte Code, aber du könntest bei deinem Originalcode in der Methode Result2Memo einfach mal das globale Settings.Show_Errors auf False setzen. Damit änderst du (in der Realität vermutlich ungewollt) das Programmverhalten. Mit der Klassenlösung ist sowas gar nicht erst möglich.

[NoGAD]

Zitat:

Zitat von Uwe Raabe (Beitrag 1460903)

Allerdings kann jeder seine eigene Instanz erzeugen und eigene Settings verwenden. Der Instanz und den Settings in Button1Click ist das aber egal.

Und warum muss es eine eigene Klasse sein?

Würde es nicht ausreichen, wenn ich den Record deklariere, um diesen dann als Variable in einer anderen Unit zu nutzen?

[stahli]

Grundsätzlich sind globale Variablen nichts schlechtes.

Generell sollten alle Konstrukte möglichst dort definiert sein, wo sie gebraucht werden.
Das beugt Nebeneffekten und Fehlern vor.

Wenn man projektweit globale Eigenschaften oder Funktionen braucht, dann kann man die auch global definieren.
Man muss nur vernünftig damit umgehen und aufpassen, dass man die nicht leichtfertig falsch verwendet.

Manche Maßnahmen, globale Variablen vermeiden zu wollen, bringen letztlich nur unnötigen Aufwand.
Man kann z.B. Variablen in Klassen statt nur in Units einbetten, das würde ich aber danach entscheiden, ob es dadurch tatsächlich übersichtlicher wird oder andere Vorteile (wie z.B. Klassenkonstruktoren o.ä.) mit sich bringt.

Also: Globale Variablen (nur) ersetzen, wenn es Sinn macht.