Custom compiler message beim Aufruf einer Methode möglich?

[himitsu]

Free ist nur Public und es wäre besser, wenn man das auch noch im Destructor prüft.
(Beispiel: siehe EOutOfMemory in der SysUtils)

Warnungen kann man ignorieren.


[edit]
OK, nicht Destructos, sondern FreeInstance.

Delphi-Quellcode:

uses SysConst, Dialogs;

procedure TForm1.FormCreate(Sender: TObject);
var E: EOutOfMemory;
begin
  E := EOutOfMemory.CreateRes(@SOutOfMemory);
  E.Free;
  ShowMessage('bin noch da: ' + E.Message);

  // und an das nötige private E.AllowFree:=True; kommt man nicht ran
end;

also am Einfachsten diese Beiden überschreiben.

Delphi-Quellcode:

class function NewInstance: TObject; virtual;
procedure FreeInstance; virtual;

in NewInstance prüfen ob es schon existiert und ansonsten eine Exception
und in FreeInstance prüfen ob es freigegeben werden darf

[Stevie]

Da ich den Ansatz mit class constructor und class property gewählt habe, kommt auch das Überschreiben von NewInstance und FreeInstance leider nicht in Frage, da niemals ein Objekt der Singleton Klasse selber erzeugt wird.

[himitsu]

OK, dann einfach nur NewInstance überschreiben, denn wenn da wirklich mal einer eine Instanz erzeugen will und dabei sämtliche Warnungen ignoriert, dann schmeißt du ihm darin einfach eine Exception entgegen. :zwinker:

dann ist das aber kein Singelton mehr.
Singelton = nur maximal eine Instanz der Klasse exisitert

[Stevie]

Zitat:

Zitat von himitsu

OK, dann einfach nur NewInstance überschreiben, denn wenn da wirklich mal einer eine Instanz erzeugen will und dabei sämtliche Warnungen ignoriert, dann schmeißt du ihm darin einfach eine Exception entgegen. :zwinker:

dann ist das aber kein Singelton mehr.
Singelton = nur maximal eine Instanz der Klasse exisitert

So hab ich das jetzt auch gelöst. Genauer gesagt, ist meine Klasse eher eine Art generischer Wrapper um aus einer anderen Klasse (diese darf natürlich dann nicht nach außen bekannt sein, damit man keine Instanz erzeugt) ein Singleton zu erzeugen. Die Idee ist mit durch diesen Artikel gekommen.

[himitsu]

Wenn die Klasse nach außen wirklich nicht sichtbar sein soll,
dann kannst du auch ganz böse sein und alles auf einen Record umstellen.
Von diesem kann man garantiert keine Instanz erstellen. :lol:

Delphi-Quellcode:

unit SingletonUnit;

interface

type
  {T}Singleton = record
    class procedure DoSomething;
  end;

implementation

type
  TInternalSingleton = class
    constructor Create;
    procedure DoSomething;
  end;

var FSingle: TInternalSingleton;

constructor TInternalSingleton.Create;
begin
  ...
end;

procedure TInternalSingleton.DoSomething;
begin
  ...
end;

class procedure TSingleton.DoSomething;
begin
  FSingle.DoSomething;
end;

initialization
  FSingle := TSingleton.Create;

finalization
  FSingel.Free;
end.

Wobei man hier auch teilweise komplett auf die interne Klasse verzichten könnte.

[Stevie]

Die Idee war eher folgende:

Delphi-Quellcode:

unit Singleton;

interface

type
  TSingleton<T: class, constructor> = class
  private
    class var FInstance: T;
    class constructor Create;
    class destructor Destroy;
  public
    class function NewInstance: TObject; override;
    class property Instance: T read FInstance;
  end;

implementation

uses
  SysUtils;

class constructor TSingleton<T>.Create;
begin
  FInstance := T.Create;
end;

class destructor TSingleton<T>.Destroy;
begin
  FInstance.Free;
end;

class function TSingleton<T>.NewInstance: TObject;
begin
  raise Exception.CreateFmt('Instantiation of TSingleton<%s> not allowed', [T.ClassName]);
end;

end.

In einer anderen unit wird dann z.B. TFooSingleton = class(TSingleton<TFoo>) deklariert und auch nur diese Klasse nach außen freigegeben. Auch die unit Singleton sollte nicht im uses benutzt werden, sondern nur die, wo die konkrete Singleton-Klasse definiert wurde (in dem Beispiel TFooSingleton).