Klassen-Konstruktion einmal anders...

[maynard]

Tach...

Zitat von maximov:

Bei ersterer variante hab ich ja auch eine typisierte klassenvariable und bei der liste natürlich nicht, da sie ja nur aus pointern besteht.

Irgendwie is das wohl in vergessenheit geraten, das TList nur untypisierte Pointer zurückgibt ... perinlich, peinlich

Zitat von maximov:

wobei die frage wäre ob das sinn macht, da so die klassen ziemlich undifferenzierbar in der liste rum wabern. Eine stringliste macht da schon mehr sinn...ich weiss ja nicht was du vor hast?

Zitat von maximov:

Macht aber keinen sinn stundenlang drüber zu reden, wenn du nicht sagst was genau du vor hast. Denn meist gibt es einen eleganteren weg!

Also bzgl. des Sinns oder ganz und gar Unsinns meines Vorhabens bin ich mir noch nicht so sicher. Grundgedanke der ganzen Sache ist es dem Programm Mehrsprachigkeit zu ermöglichen. Woran ich gerade schreibe, ist ein Exception Manager der Teilstück des gesamten Sprachmanagments wird/ist. Für jede spezielle Exception leite ich einfach eine Klasse von Exception ab ohne etwas zu überschreiben [man könnte ja auch den Konstruktor überschreiben und dort den Meldungstext/Resourcestring, HilfeID ... zuweisen]. Zur Laufzeit wird dann eben der richtige Konstruktor rausgesucht und die betreffenden Parameter übergeben. Der Manager speichert die ganzen zugehörigen Daten in Datei(n) und so kann man halt mehrsprachig arbeiten. Im Großen und Ganzen finde ich den Ansatz eigentlich gut ... blos bei einzelnen Umsetzungen im Detail bin ich mir noch nicht ganz sicher bzw. wozu würdest du mir denn bei diesem Problem raten?

MfG maynard

[maximov]

Vorstellen könnte ich mir, das du die wichtigsten konstruktoren überdeckst und nur einen key (anstatt der message) übergibst und dann die exception-klasse sich die message holt und an die vorfahren weitergibt:

Delphi-Quellcode:

type
  TLokiExceptionClass = class of TLokiException ; 

  TLokiException = class(Exception)
  protected
    class function ResolveMsg(const aKey:string):string; 
  public
    constructor Create(const key: string); reintroduce;
    constructor CreateFmt(const key: string; const Args: array of const); reintroduce;
  end;

...

{ TLokiException }

constructor TLokiException.Create(const key: string);
begin
  inherited Create(ResolveMsg(key));
end;

constructor TLokiException.CreateFmt(const key: string;
  const Args: array of const);
begin
  inherited CreateFmt(ResolveMsg(key),Args);
end;

class function TLokiException.ResolveMsg(const aKey: string): string;
begin
  result := GetMsgFromAnywhere(aKey); // musst du selbst implementieren
end;

Metaklassen brauchst du dann eigentlich nicht, obwohl man das vielleicht auch nutzen kann. mal sehn, aber erstmal das hier. Ein aufruf könnte dann so aussehen:

Delphi-Quellcode:

...
raise EIrgendWasIstFaul.create('<IWIF>');

damit würdest du vermeiden, dass du explizite texte angeben musst, sondern nur einen key. So du kannst jetzt nutürlich noch vereinfachungen mit metaklassen machen. zB.:

Delphi-Quellcode:

...
// anstatt direkt zu 'raisen' eine procedure beauftragen:
RaiseMyError('<IWIF>');
...
procdure RaiseMyError(const aKey:string);
var EClass:TLokiExceptionClass; 
begin

  EClass:=TLokiExceptionClass( ? list.indexOfObject(aKey).Object.wasWeissIch ? );

  if ECLass <> nil then
    raise EClass.create(aKey)
  else
   raise Exception('Unknown exception :'+aKey);
end;

Macht das sinn? Müsste man vielleicht nochmal überdenken. Letztendlich muss es dir genehm sein Will dir ja nix aufdrängen.