MustOverride?

[stahli]

So ein MustOverride gibt es nicht - oder?

Delphi-Quellcode:

MyClass = class
  procedure MyMethode; virtual; mustoverride;

Der Compiler sollte somit meckern, wenn man einmal vergisst, die Methode in einer abgeleiteten Klasse zu überschreiben.
Quasi ein Abstract, aber bei jeder Vererbung.

[TBx]

??? Das was Du da haben möchtest, ist doch genau der abstract. Oder stehe ich da jetzt irgendwie auf dem Schlauch?

[geskill]

Ich glaube er meint, dass auch in der nächst tieferen Vererbungstiefe wieder ein override stattfinden muss.

Delphi-Quellcode:

TBaseClass = class
  procedure MyMethode; virtual; mustoverride;

TBasicClass = class(TBaseClass)
  procedure MyMethode; override; // requires override

TSpecificClass = class(TBasicClass)
  procedure MyMethode; override; // requires override

Ich wüsste nicht, dass es sowas gibt.

[stahli]

Genau, was geskill schreibt.

Die zweite Ableitung wird dann nicht mehr beanstandet wenn sie die Methode nicht selbst nochmal überschreibt.
Und MustOverride könnte dennoch eine Deklaration der Basismethode ermöglichen.

[TBx]

Wozu möchtest Du sowas haben? Ich kann dafür so aus dem Stehgreif keinen sinnvollen Anwendungsfall entdecken.

[stahli]

In meinem Fall für Aufräumaktionen für mehrere Klassen und Interfaces.
Jede Ableitung muss bestimmte Dinge beachten und daher i.d.R. die Methode überschreiben.

Natürlich BRAUCHT man das Attribut nicht. Aber es könnte bei der Fehlervermeidung helfen.

[geskill]

Du konntest es vielleicht so machen:

Delphi-Quellcode:

type
  TBaseFunctions = class
    procedure MyMethode1; virtual; abstract;
    procedure MyMethode2; virtual; abstract;
  end;

  TBaseFunctionsMeta = class of TBaseFunctions;

  TBaseClass = class
    function GetFunctions: TBaseFunctionsMeta; virtual; abstract;
  end;

  //
  TBasicSpecificFunctions = class(TBaseFunctions)
    procedure MyMethode1; override;
    procedure MyMethode2; override;
  end;

  TBasicClass = class(TBaseClass)
    function GetFunctions: TBaseFunctionsMeta; override;
  end;

  //
  TSpecificSpecificFunctions = class(TBaseFunctions)
    procedure MyMethode1; override;
    procedure MyMethode2; override;
  end;

  TSpecificClass = class(TBasicClass)
    function GetFunctions: TBaseFunctionsMeta; override;
  end;

Du hast eine Klasse TBaseFunctions die bestimmte Funktionen realisiert, die jedes Mal neu definiert werden müssen.

Du erbst immer nur von TBaseFunctions.

Innerhalb der Hierarchie TBasicClass, TSpecificClass ... greifst du mittels GetFunctions auf diese Funktionen zu.

Aber auch hier musst du das override von GetFunctions sicherstellen, aber eben nur einmalig.

Jedoch müsstest du dafür existierenden Code umschreiben. Ob das so sinnvoll wäre. Ich würde lieber per Notepad++ und regulären Ausdrücken prüfen, ob ein override vorhanden ist.

[stahli]

Danke für die Mühe.
Aber dann schaue ich lieber von Hand durch, ob ich die Methoden überall korrekt überschrieben habe.

Hätte ja sein können, dass ich ein passendes Attribut nicht kenne.
Die Hilfe ist ja da nicht immer eine solche.

[Sir Rufo]

Ein klarer Fall für Unittests

Eine Prüfmethode kann per RTTI die deklarierten Methoden abfragen.

Allerdings reicht es auch, wenn man das korrekte Verhalten überprüft (z.B. werden alle erzeugten Instanzen auch wieder freigegeben)

[Uwe Raabe]

Zitat von stahli:

In meinem Fall für Aufräumaktionen für mehrere Klassen und Interfaces.
Jede Ableitung muss bestimmte Dinge beachten und daher i.d.R. die Methode überschreiben.

Mein gängiges Muster in so einem Fall ist dies:

Delphi-Quellcode:

type
  TBaseClass = class
  private
    procedure CommonCleanup;
  protected
    procedure InternalCleanup; virtual; abstract;
  public
    procedure Cleanup;
  end;

  TDerivedClass = class(TBaseClass)
  protected
    procedure InternalCleanup; override;
  end;

procedure TBaseClass.Cleanup;
begin
  CommonCleanup;
  InternalCleanup;
end;