Objekt als Rückgabe von Funktion - Wie elegant Freigabe regeln?

[Namenloser]

Wie wäre es mit einem Observer-Pattern? Das Objekt schickt dann bei Freigabe einfach eine entsprechende Nachricht an den Beobachter.

Skizze:

Delphi-Quellcode:

TTask = class;

ITaskObserver = interface
  procedure Observe(Task: TTask);

  procedure OnProgressChanged(Task: TTask; Progress: integer);
  procedure OnTaskDestroyed(Task: TTask);
end;

TTask = class{(TThread?)}
protected
  FObserver: ITaskObserver ;
  {...}
public
  {...}
  procedure Abort;
  constructor Create(Observer: ITaskObserver);
  destructor Destroy; override;
end;

TTaskFactory = class
  procedure CreateTask(Observer: ITaskObserver): TTask;
end;

implementation

constructor TTask.Create(Observer: ITaskObserver);
begin
  FObserver := Observer;
  FObserver.Observe(Self);
end;

destructor TTask.Destroy; override;
begin
  FObserver.OnTaskDestroyed(Self);
  inherited;
end;

procedure TTaskFactory.CreateTask(Observer: ITaskObserver): TTask;
begin
  Result := TTask.Create(Observer);
end;

Delphi-Quellcode:

TTaskController = class(TInterfacedObject, ITaskObserver)
protected
  FTasks: TList<TTask>;

  procedure Observe(Task: TTask);

  procedure OnProgressChanged(Task: TTask; Progress: integer);
  procedure OnTaskDestroyed(Task: TTask);
end;

procedure TTaskController.Observe(Task: TTask);
begin
  FTasks.Add(Task);
end;

procedure TTaskController.OnTaskDestroyed(Task: TTask);
begin
  FTasks.Remove(Task);
end;

In FTasks stehen dann eben jeweils die gültigen Tasks. Da könnte man z.B. dann TTask.Abort aufrufen.

Ist jetzt bewusst einfach gehalten, man könnte natürlich auch eine ganze Liste von Observern pro Objekt verwalten...