Ich habe ein kleines Design-Problem. Und zwar habe ich eine Klasse, die Dateien laden und speichern können soll. Da dies auch mal etwas dauern kann, muss beides in einen Thread ausgelagert werden. Nehme ich jetzt ide VCL TThread-Klasse, habe ich aber nur eine Execute-Methode. Ich bräuchte aber zwei, eine zum Laden und eine zum Speichern. Ich könnte jetzt zwar in der Execute-Methode einfach einen Flag auslesen und dann das eine oder das andere machen. Aber geht es irgendwie eleganter?

Ich hatte das bisher so gelöst, dass ich eine übergeordnete Klasse benutzt habe und dann davon TSave bzw. TLoad abgeleitet habe. Das finde ich allerdings etwas blöd.

Gibt es da eine bessere Lösung, als die, die mir bisher eingefallen sind?

Du musst Execute ja nicht zwingend direkt aufrufen: wenn Du ein Objekt für beides willst, aber Dir einfach das Flag sparen, nimm zwei Methoden, LoadFromFile & SaveToFile, die das Flag setzen und den Dateinamen in Objektvariable umkopieren, und danach Execute aufzurufen. Und in Execute dann je nach Flag entweder IntLoadFromFile oder IntSaveToFile (interne Methoden, die das Laden/Speichern erledigen) aufrufen.

So ist 1. am Namen der aufrufenden Methode klar, was getan werden soll, und 2. der Code auch im Thread sauber getrennt. Würde ich zumindest so machen, weiß nicht ob ich richtig verstanden habe, worauf Du hinaus willst.

Du hast mich schon richtig verstanden. Also du würdest das dann auch mit einem Flag machen. Hm.

Zitat von Luckie:

Ich hatte das bisher so gelöst, dass ich eine übergeordnete Klasse benutzt habe und dann davon TSave bzw. TLoad abgeleitet habe.

Das ist doch elegant, in meinen Augen. Und die TSave bzw. TLoad setzt im constructor das Flag in der Mutterklasse und ruft Execute auf. Ist zwar dann genau das Gleiche, als ob du die Flags selbst von aussen setzt, hat aber eben den eleganten Vorteil, dass du eine Load und eine Save Klasse zur Verfügung hast, und du von aussen nicht drum kümmern musst, das Flag zu setzen.

Du könntest natürlich auch weiter mit einer Klasse arbeiten, und den Thread Konstruktor durch einen Parameter erweitern. Das stellt dann sicher, dass auch nicht vergessen wird, das Lese oder Schreibflag zu setzen.

markieren

Delphi-Quellcode:

type
  TWorkflag = (wfLoad, wfSave) ;

  TMyThread = class (TThread)
     FWorkFlag : TWorkFlag ;
  public
     constructor Create (AWorkFlag : TWorkFlag) ; reintroduce ;
  end ;

Also, ich habe es jetzt so:

zusammenfalten · markieren

Delphi-Quellcode:

type
  { Thread operation: saveing or loading a template }
  TThreadOperation = (toSave, toLoad);

  TOnTemplateBegin = TNotifyEvent;
  TOnTemplateProgress = TNotifyEvent;
  TOnTemplateEnd = TNotifyEvent;

  TTemplate = class(TThread)
  private
    FFilename: WideString;
    FThreadOperation: TThreadOperation;
    procedure Save;
    procedure Load;
  protected
    procedure Execute; override;
  public
    procedure SaveToFile(Filename: WideString);
    procedure LoadFromFile(Filename: WideString);
  end;

implementation

{ TTemplate }

procedure TTemplate.Execute;
begin
  inherited;
  case FThreadOperation of
    toSave: Save;
    toLoad: Load;
  end;
end;

procedure TTemplate.Load;
begin

end;

procedure TTemplate.LoadFromFile(Filename: WideString);
begin
  FFilename := Filename;
  FThreadOperation := toLoad;
  Resume;
end;

procedure TTemplate.Save;
begin

end;

procedure TTemplate.SaveToFile(Filename: WideString);
begin
  FFilename := Filename;
  FThreadOperation := toSave;
  Resume;
end;

markieren

Delphi-Quellcode:

procedure TForm1.Button2Click(Sender: TObject);
var
  Template: TTemplate;
begin
  Template := TTemplate.Create(False);
  Template.FreeOnTerminate;
  Template.LoadFromFile('foobar');
end;