Generische Ableitung einer Klasse

[s.h.a.r.k]

Hallo zusammen,

wollte gerade sowas hier schreiben, nur leider klappt das nicht:

Delphi-Quellcode:

TThreadedObject<T: class> = class(T)

end;

Der Cursor bleibt hinter dem T bei class(T) stehen und der Compiler meldet:

Code:

[DCC Fehler] ApCore.Classes.pas(68): E2021 Klassentyp erwartet

Weiß jemand warum das so ist?

Ziel des ganzen ist es einer beliebigen Klasse eine CriticalSection samt Lock/Unlock-Methoden zu spendieren, ohne da jetzt jedes erst von der Klasse ableiten zu müssen und den kompletten Code immer wieder zu schreiben.

[Neutral General]

Wie wäre es mit

Delphi-Quellcode:

TThreadedObject<T: class> = class

end;

? o.O

Edit: Achso.. du meinst das anders.. Ne.. das geht nicht..

[s.h.a.r.k]

Und warum nicht?

[Neutral General]

Wie soll man die Klasse denn programmieren?

Du kannst keine Methoden überschreiben, du weißt nicht welche Methoden/Properties/Variablen dir zur Verfügung stehen.. Du weißt gar nichts. Wie willst du denn auf dieser Grundlage eine Klasse ableiten/implementieren?

[uligerhardt]

Zitat von Neutral General:

Du kannst keine Methoden überschreiben, du weißt nicht welche Methoden/Properties/Variablen dir zur Verfügung stehen.. Du weißt gar nichts. Wie willst du denn auf dieser Grundlage eine Klasse ableiten/implementieren?

Will/braucht er ja auch nicht:

Zitat von s.h.a.r.k:

Ziel des ganzen ist es einer beliebigen Klasse eine CriticalSection samt Lock/Unlock-Methoden zu spendieren, ohne da jetzt jedes erst von der Klasse ableiten zu müssen und den kompletten Code immer wieder zu schreiben.

[Neutral General]

Das hat doch nichts damit zu tun was er will oder braucht

Der Ansatz an sich macht (OOP-technisch) keinen Sinn.

Für sowas sind Class-Helper gedacht.

[uligerhardt]

Zitat von s.h.a.r.k:

Ziel des ganzen ist es einer beliebigen Klasse eine CriticalSection samt Lock/Unlock-Methoden zu spendieren, ohne da jetzt jedes erst von der Klasse ableiten zu müssen und den kompletten Code immer wieder zu schreiben.

Vielleicht kannst du Arme-Leute-RAII mittels Interfaces nutzen. Ich hab z.B. sowas für die temporäre Anzeige von Cursorn:

Delphi-Quellcode:

interface

type
  ICursorGuard = interface
  end;

function GuardCursor(NewCursor: TCursor = crHourGlass): ICursorGuard;

implementation

type
  TCursorGuard = class(TInterfacedObject, ICursorGuard)
  private
    FOldCursor: TCursor;
  public
    constructor Create(NewCursor: TCursor);
    destructor Destroy; override;
  end;

{ TCursorGuard }

constructor TCursorGuard.Create(NewCursor: TCursor);
begin
  inherited Create;
  FOldCursor := Screen.Cursor;
  Screen.Cursor := NewCursor;
end;

destructor TCursorGuard.Destroy;
begin
  Screen.Cursor := FOldCursor;
  inherited Destroy;
end;

function GuardCursor(NewCursor: TCursor = crHourGlass): ICursorGuard;
begin
  Result := TCursorGuard.Create(NewCursor);
end;

Das kannst du dann so aufrufen:

Delphi-Quellcode:

procedure Test;
var
  Guard: ICursorGuard;
begin
  Guard := GuardCursor;
  //Mach was langwieriges
end;

// oder sogar so:
procedure Test;
begin
  GuardCursor;
  //Mach was langwieriges
end;

[Bummi]

@uligerhardt

nett ....