Cleancode, Dependency Injection oder wie stelle ich mich richtig an

[TiGü]

Hm, irgendwie habe ich das Gefühl das wichtige Informationen oder zumindest ein kleines Codebeispiel vom Ist-Zustand fehlen.

Auf jeden Fall sollte deine visuelle Komponente NICHT diese ID kennen, sondern nur deine Klasse, die für das speichern zuständig ist.

[Ralle1]

Delphi Version XE3.

Hier ein kleines Codebeispiel (ich war davon ausgegangen, dass dies nicht mehr Aussagekraft hat, als mein engehender Text).
Den realen Code kann ich aufgrund des Umfangs schlecht hier unterbringen:

Delphi-Quellcode:

type
  TFormMain = class(TForm)
    PageControlMain: TMyPageControl;
    TabSheet1: TMyTabSheet;
    TabSheet2: TMyTabSheet;
    TabSheet3: TMyTabSheet;
    procedure FormCreate(Sender: TObject);
  private
    { Private-Deklarationen }

  public
    { Public-Deklarationen }
  end;

var
  FormMain: TFormMain;
  fUserID : integer;  //globale User ID

implementation

{$R *.dfm}

procedure TFormMain.FormCreate(Sender: TObject);
begin
  fUserID := GetGlobalUserID; //globale User ID wird von wo auch immer gesetzt bei Programmstart
end;

(******************************************************************************)

type
  TMyPageControl = class(TComponent)
  private
    { Private-Deklarationen }
    Settings : TControlSettings;
  public
    { Public-Deklarationen }
  end;

(******************************************************************************)

type
  TControlSettings = class
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
    procedure SaveSettingstoDatabase;
  end;


implementation

procedure TControlSettings.SaveSettingstoDatabase;
begin
  //Hier wird die globale UserID benoetigt
end;

(******************************************************************************)

[stahli]

Eine einfache Lösung wäre folgende:

Delphi-Quellcode:

type
   TControlSettings = class
   private
     { Private-Deklarationen }
   public
     { Public-Deklarationen }
     class var UserId: Integer;
     procedure SaveSettingstoDatabase;
   end;

...

procedure TFormMain.FormCreate(Sender: TObject);
begin
  fUserID := GetGlobalUserID; //globale User ID wird von wo auch immer gesetzt bei Programmstart
  TControlSettings.UserId := fUserId;
end;

[himitsu]

Man kann das Event auch als Class-Property oder über eine Register-Klassenprozedur integrieren, welche den Callback allen Instanzen/Nachkommen der Klasse zur Verfügung stellt.
[edit] siehe #7 und das in der Klasse kommt zwar auf's "Gleiche" raus, wie das in #6, aber diese globalen Variablen sollte man meistens gleich verbieten. [/edit]

Falls kein Callbck angegeben wurde, könnte intern problemlos zumindestens eine ID aus GetUserName+GetComputerName erzeugt werden.
Irgendwie müsste es auch möglich sein die BenutzerID (GUID) des Benutzerkontos vom Windows zu erfragen. (die wäre theoretisch weltweit eindeutig)

[TiGü]

Einfach in verschiedene Units aufteilen?!?

Delphi-Quellcode:

unit Component;

interface

uses
  System.Classes,
  SettingsSaver;

type
  TMyPageControl = class(System.Classes.TComponent)
    private
      FSettings : TControlSettings;
  end;

implementation

end.

Delphi-Quellcode:

unit SettingsSaver;

interface

uses
  System.Classes;

type
  TControlSettings = class(TObject)
  strict private
    type
      TYourDatabase = class(TObject)
        function Save(AUserID : Integer) : Boolean;
      end;
  private
    FDatabase : TYourDatabase;
  public
    function SaveSettingstoDatabase : Boolean;
  end;

implementation

uses
  User;

function TControlSettings.SaveSettingstoDatabase : Boolean;
begin
  Result := FDatabase.Save(User.GetUserID)
end;

function TControlSettings.TYourDatabase.Save(AUserID : Integer) : Boolean;
begin
  Result := AUserID > 0;
end;

end.

Delphi-Quellcode:

unit User;

interface

function GetUserID : Integer;

implementation

function GetUserID : Integer;
begin
  Result := 1234;
end;

end.

[Uwe Raabe]

Zitat von Ralle1:

Delphi-Quellcode:

procedure TControlSettings.SaveSettingstoDatabase;
begin
  //Hier wird die globale UserID benoetigt
end;

Du könntest hier den Zugriff auf die Database über einen Wrapper realisieren, der die Zugriffe auf die UserID vor TControlSettings verbirgt. TControlSettings arbeitet dann mit einer abstrakten Klasse. Die davon abgeleitete Klasse bekommt dann die UserID mit.

Aber da aus deinem Code die tatsächliche Verwendung der UserID nicht hervorgeht (insofern bringt er wirklich nicht mehr als deine ursprüngliche Beschreibung), kann man halt auch keine genaueren Hinweise geben.

[Ralle1]

Danke erstmal für das zahlreiche Feedback
Daraus fasse ich folgende Lösung für mich als am sinnvollsten zusammen:

Delphi-Quellcode:

type
   TApplicationUser = class
   private
     { Private-Deklarationen }
   public
     { Public-Deklarationen }
     class var UserId: Integer;
   end;

...

type
   TControlSettings = class
   private
     { Private-Deklarationen }
     User : TApplicationUser;
   public
     { Public-Deklarationen }
     procedure SaveSettingstoDatabase;
   end;

...

procedure TFormMain.FormCreate(Sender: TObject);
begin
  fUserID := GetGlobalUserID; //globale User ID wird von wo auch immer gesetzt bei Programmstart
  TApplicationUser.UserId := fUserId;
end;

Allerdings habe ich dabei den Ansatz von Uwe noch nicht beachtet, weil ich ihn noch nicht genau verstanden habe.
Um die Dir fehlende Info nachzureichen:
In der Methode "SaveSettingsToDatabase" sollen die Einstellungen dann in die Datenbank geschoben werden, also Query-Objekt erzeugen und ein Update/Insert auf eine Tabelle abfeuern.
Die UserId bildet dabei den Foreignkey. Über eine weitere Methode Methode "LoadSettingsFromDatabase" wird dieser Datensatz später wieder ausgelesen

[Sir Rufo]

Also du hast da irgendwelche Komponenten und da sollen Einstellungen gelesen und geschrieben werden.

Du brauchst also eine TReader und TWriter Klasse, die abstrakt Eigenschaften lesen und schreiben können. Mehr muss die Komponente doch gar nicht wissen, wohin und mit wem kann der doch egal sein.

Delphi-Quellcode:

TMyComponent = class( TComponent )
public
  procedure ReadSettings( AReader : TReader );
  procedure WriteSettings( AWriter : TWriter );
end;

Dann benötigst du eine abstrakte TSettingsStore Klasse, die eine TReader und TWriter -Instanz zur Verfügung stellt.

Jetzt werden wir konkreter:

Du leitest dir von TSettingsStore eine Klasse ab, die mit einer Datenbank kommunizieren kann und auch eine UserID aufnehmen kann.

[Ralle1]

dieser Ansatz setzt allerdings voraus, dass ReadSettings und WriteSettings von außen aufgerufen wird, oder?

Delphi-Quellcode:

procedure TFormMain.FormCreate(Sender: TObject);
begin
  ...
  MyPageControl.ReadSettings(SettingsStore.Reader);
  ...
end;

procedure TFormMain.FormClose(Sender: TObject; var Action: TCloseAction);
begin
  ...
  MyPageControl.WriteSettings(SettingsStore.Writer);
  ...
end;

Dies ist nämlich nicht der Fall. Die Komponente kümmert sich eigenständig um das Auslösen dieser Ereignisse.

[Sir Rufo]

Und wo ist jetzt das Problem daraus Events zu machen und entsprechend zu verdrahten?

Irgendwo musst du ansetzen und etwas übergeben, ansonsten legst du dich starr fest.
Wo ist egal, und wenn die Komponenten einfach ein "Singleton" ansprechen und sich darüber die Instanz zum Speichern/Laden holen.

Diesem Singleton übergibst du dann einfach beim Start der Anwendung die konkrete Instanz und gut.

Also mal ganz simpel:

Delphi-Quellcode:

unit MyUserSettings;

interface

type
  IUserSettingsStorage = interface
    ['{F3E5657B-39EF-4FA1-A601-8AFCEE50D6D1}']
    procedure WriteString( const AName, AValue : string );
    function ReadString( const AName, ADefault : string ) : string;
  end;

  TUserSettings = class
  private
    class var _Storage : IUserSettingsStorage;
  private
    class function GetStorage : IUserSettingsStorage; static;
    class procedure SetStorage( const Value : IUserSettingsStorage ); static;
  public
    class property Storage : IUserSettingsStorage read GetStorage write SetStorage;
  end;

implementation

{ TUserSettings }

class function TUserSettings.GetStorage : IUserSettingsStorage;
begin
  // Wenn _Storage NIL, dann könnte man auch eine DUMMY/NULL-Instanz zurückgeben, die einfach nichts macht
  // dann spart man sich die Überprüfung, ob es eine Instanz gibt
  Result := _Storage;
end;

class procedure TUserSettings.SetStorage( const Value : IUserSettingsStorage );
begin
  _Storage := Value;
end;

end.

und in der Komponente dann

Delphi-Quellcode:

interface

type
  TMyComponent = class(...)
  protected
    procedure DoLoadUserSettings;
    procedure DoSaveUserSettings;
  end;

implementation

uses
  MyUserSettings;

procedure TMyComponent.DoSaveUserSettings;
begin
  TUserSettings.Storage.WriteString( 'Name', Name );
end;

procedure TMyComponent.DoLoadUserSettings;
begin
  Name := TUserSettings.Storage.ReadString( 'Name', Name );
end;

Es gibt da natürlich noch eine ganze Bandbreite an Spielmöglichkeiten.

Die Storage gibt mir eine spezielle Instanz für die Komponente zurück TUserSettings.Storage('TForm1.PageControl1').WriteString('Name',Name); etc., etc.