Globale Variablen in OO-Liste verwalten

[4dk2]

Zu meiner Frage:
http://www.delphipraxis.net/188803-s...berwachen.html
hab ich hier mal meine Lösung zur Verwaltung von Globalen Variablen. Dies ist zwar nicht die Lösung wie man direkt die Speicher-Adressen
der Variablen überwachen kann, jedoch lassen sich hiermit, die Werte aller Variablen abspeichern und vergleichen.

Ich habe kurz gefasst bei mir das Problem, dass ich ca 300 globale Variablen habe, die für Berechnungen verwendet werden.
Primär ist bei mir das Problem, dass ich später vergleichen möchte, welche der Variablen verändert worden sind.
Alle manuell vergleichen ist praktisch unmöglich, oder automatisch generiert, erzeugt dies sehr viel Zeilen unnötigen Code.

Hier ein Beispiel, die Unit zur TVarList ist im Anhang.

Delphi-Quellcode:

var
  x,x2:double;
  IntWert1:integer;
  IntWert2:integer;

implementation

{$R *.dfm}

procedure CalcIrgendwas(var a,b:double);
begin
  b:=sqr(a);
end;

procedure TForm1.Button1Click(Sender: TObject);
var itest:integer;
    dtest:double;
    FVars:TVarList;
begin
  FVars:=TVarList.Create;
  try
    // Variablen dem Verwalter hinzufügen...
    FVars.Add('IntWert1',@IntWert1,varInteger);
    FVars.Add('IntWert2',@IntWert2,varInteger);
    FVars.Add('x',@x,varDouble);
    FVars.Add('x2',@x2,varDouble);
    //##############################################################

    //init werte...
    IntWert1:=100;
    IntWert2:=200;
    x:=pi;
    x2:=pi*2;


    FVars.StoreCurrentValues; //aktuelle werte der variablen merken

    x:=1.22345;
    CalcIrgendwas(x2,x); //var parameter!

    //showmessage('SimpleCompareOK='+booltostr(FVars.SimpleCompareOK,true));
    Memo1.Lines.Add('----------------------');
    Memo1.Lines.Add('Compare1: ');
    FVars.CompareList(Memo1.Lines,true); //vergleichen der werte...

    IntWert2 :=7654321;

    //bidirektionaler Zugriff über die Liste:
    itest:=FVars['IntWert1'].asInteger;
    FVars['IntWert1'].asInteger:=123456;
    itest:=FVars['IntWert1'].asInteger;

    dtest:=FVars['x'].asDouble;
    FVars['x'].asDouble:=1.123456789;
    dtest:=FVars['x'].asDouble;


    //--------------
    //showmessage('SimpleCompareOK='+booltostr(FVars.SimpleCompareOK,true));
    Memo1.Lines.Add('----------------------');
    Memo1.Lines.Add('Compare2: ');
    FVars.CompareList(Memo1.Lines,true);//vergleichen der werte...
  finally
    FVars.Free;
  end;

end;

Kurz erklärt:
FVars.Add('x',@x,varDouble); fügt den Pointer der Variablen einer Liste hinzu.
Danach kann man im Prinzip auf die Variable "X", die im globalen Kontext steht, per Liste zugreifen, oder per Variable.
Z.b. wenn man die TVarList erweitern würde, kann man auch einfach alle Variablen aus ner Datenbank laden, und/oder zurück schreiben.

Warum das ganze nicht per OOP in Klassen?
-Weil mein Fall, wo ich das brauchte, aus über 10k Zeilen Berechnungen besteht und die über 100 Funktionen/Proceduren die darin vorkommen, var Parameter benutzen.
und Properties nicht als var übergeben werden können.

ACHTUNG!
Diese Art der Verwaltung eignet sich nur für Variablen, die im Gleichen Kontext bleiben!
-Ändert sich die Pointer Adresse der Variable, bekommt die Liste davon nix mit.
-Wird eine Variable hinzugefügt wie z.b.:

Delphi-Quellcode:

procedure addY;
var y:double;
begin
FVars.Add('y',@y,varDouble);
end;
...
FVars['y'].asDouble;
...

liest die Liste irgendwas aus, aber nicht Y, weil der pointer auf Y ja nicht mehr existiert.

Ich weiss nicht ob überhaupt jemand hier sowas brauchen kann, oder mal braucht, aber vielleicht ist es für den Jenigen ja eine kleine Hilfe.
Es sind im Moment nur der Double und Integer Typ implementiert, aber weitere typen sind sehr einfach hinzuzufügen.