Zugriff auf Unterklasse absichern

[Blup]

Destructor Destroy natürlich immer "override". "reintroduce" unterdrückt zwar die Warnung des Compilers wenn "override" vergessen wurde. Das führt aber dazu, das dieser Destructor z.B. beim Aufruf von Free nicht aufgerufen wird.

Ein Beispiel für eine Lösung mit Nullobject:

Delphi-Quellcode:

  TMethode = class
  protected
    class var FNullObject: TMethode;
    class function CreateNullObject: TMethode;
    class function GetNullObject: TMethode;
  public
    class property NullObject: TMethode read GetNullObject;
  private
    FNo: Integer;
    FName: String;
  protected
    procedure SetNo(AValue: Integer); virtual;
    procedure SetName(const AValue: string); virtual;
  public
    constructor Create;
    destructor Destroy; override;
    function IsNullObject: Boolean;
    property No: Integer read FNo write SetNo;
    property Name: String read FName write SetName;
  end;

  TAnalyse = class
  private
    FNo: Integer;
    FName: String;
    FMethode : TMethode;
    function GetMethode: TMethode;
    procedure SetMethode(AValue: TMethode);
  public
    constructor Create;
    destructor Destroy; override;
    property No: Integer read FNo write FNo;
    property Name: String read FName write FName;
    property Methode: TMethode read GetMethode write SetMethode;
  end;

implementation

class function TMethode.CreateNullObject: TMethode;
begin
  Result := TMethode.Create;
end;

class function TMethode.GetNullObject: TMethode;
begin
  if not Assigned(FNullObject) then
    FNullObject := CreateNullObject;

  Result := FNullObject;
end;

procedure TMethode.SetNo(AValue: Integer);
begin
  if IsNullObject then
    Exit;

  FNo := AValue;
end;

procedure TMethode.SetName(const AValue: string);
begin
  if IsNullObject then
    Exit;

  FName := AValue; 
end;

function TMethode.IsNullObject: Boolean;
begin
  Result := (Self = FNullObject);
end;

destructor TMethode.Destroy;
begin
  if IsNullObject then
    FNullObject := nil;

  inherited;
end;

function TAnalyse.GetMethode: TMethode;
begin
  if Assigned(FMethode) then
    Result := FMethode
  else
    Result := TMethode.NullObject;
end;

procedure TAnalyse.SetMethode(AValue: TMethode);
begin
  if AValue.IsNullObject then
    FMethode := nil
  else
    FMethode := AValue;
end;

finalization
  TMethode.FNullObject.Free; // oder im class-destructor

end.

[Wosi]

Hier gibt's einige Dinge, die man eleganter lösen könnte.

Einerseits können dich immutable objects vor dem unsauberen inneren Zustand des TAnalyse-Objekts schützen. Das würde bedeuten, dass Properties keine Set-Methode besitzen und daher nur lesend zur Verfügung stehen. Die Initial-Werte aller Properties werden dem Konstruktor per Parameter übergeben und können danach nicht mehr von außen verändert werden. Wenn beim Aufruf von TAnalyse.Create ein gültiges TMethod-Objekt übergeben werden muss und man es anschließend nicht mehr ändern kann, dann brauchst du dich mit Assigned-Checks nicht mehr herumplagen.
Das bedeutet natürlich auch: Möchtest du den Wert einer Property ändern, musst du dir ein neues Objekt erstellen. Das klingt zwar aufwendig aber es verhindert eine Vielzahl von Fehlern.
Nachdem ich vor ein paar Jahren Setter aus meinen Projekten verbannt habe, hat sich die Menge neuer Bugs erheblich reduziert. Viele Fehler entstehen durch inkonsistente interne Zustände von Objekten. Ohne Setter ist es erheblich leichter die Kontrolle zu behalten.

Außerdem könnte die Einhaltung des Laws of Demeter bei der Code-Qualität helfen. Das bedeutet: lange Aufruf-Ketten wie Analyse.Methode.Name sind zu vermeiden. In deinem Beispiel ist das nicht besonders schlimm. Wenn es aber um Methoden-Aufrufe geht, solltest du derartige Konstrukte eher vermeiden.

Zuguterletzt sollten Destruktoren mit override markiert werden und nicht mit reintroduce.

[norwegen60]

Zitat von Der schöne Günther:

Eine ganz andere Frage:

destructor Destroy; reintroduce;

Die wurde hier im Hause auch schon diskutiert. Der, der diese Klassen definiert hat, meint es sei nötig.

Zitat von stahli:

Man kann TAnalyse ggf. auch ein Property oder eine Funktion (Get)MethodeName spendieren, wo die Nil-Prüfung dann direkt gekapselt ist und man immer einen sinnvollen Text zurück erhält.

Wie gesagt ist die Klasse stark vereinfacht. Bevor man zu jedem Property eine Funktion schreibt, ist ein Dummy doch einfacher. Hier stört nur, dass der Code schon eine Zeit lang lebt und es Stellen gibt, die über assigned prüfen, ob mit Methoden-Parametern weiter gemacht werden kann.

Zitat von Wosi:

Einerseits können dich immutable objects vor dem unsauberen inneren Zustand des TAnalyse-Objekts schützen. Das würde bedeuten, dass Properties keine Set-Methode besitzen und daher nur lesend zur Verfügung stehen. ...

Das wäre ein erheblicher Umbau der im Moment kaum machbar ist. Trotzdem Danke für den Tip.