Nur veränderte Eigenschaften einer Klasse auslesen?

[sh17]

Ich möchte mir das "Leben" etwas vereinfachen, vielleicht bietet das aktuelle Delphi ja ein paar Konstrukte dafür, oder auch nicht, wenn ich auf dem Holzweg bin.

Ich habe eine Klasse mit mehreren Eigenschaften.

Code:

TFoo = class
public
  SomeInt : Integer;
  SomeString : String;
end;

Die Eigenschaften werden beim Erzeugen einer Instanz einmal gesetzt und ab da immer mal wieder gelesen. Jetzt kommt es vor, das z.B. einer der beiden Werte geändert wird. Am Ende der Objekt-Lebenszeit hätte ich gern eine Möglichkeit zu sagen: "Objekt, gib mir mal alle deine geänderten Werte."

Gibt es hierfür einen universellen Ansatz (bitte keine Getter/Setter, das ist zu umständlich). Wären RTTI-Attribute eine Möglichkeit? Mit Attributen hab ich noch nichts gemacht, vielleicht geht es ja auch gar nicht. Bin für jeden Tipp dankbar.

[Der schöne Günther]

"bitte keine Getter/Setter, das ist zu umständlich"

Das wäre eigentlich der richtige Weg. Alternativ lege dir doch am Anfang eine Kopie der Datenstruktur an und vergleiche dann.

Ansonsten hättest du mit Settern noch viel mehr Möglichkeiten. Logging, Begrenzung von sinnvollen Wertebereichen, all das.

[Lemmy]

Zitat von sh17:

Gibt es hierfür einen universellen Ansatz ..

klar... bau dir eine handvoll KLassen für die verwendeten Datentypen die du brauchst und ersetze deine einfachen Datentypen mit den entsprechenden Klassen. Em Ende kannst Du dann durch deine Propertyinstanzen iterieren und die geänderten in allen Geschmacksrichtungen ausgeben.


Oder du verwendest Settermethoden und pimpst diese über AOP mit einer entsprechenden Überwachung....

[sh17]

Zitat von Lemmy:

klar... bau dir eine handvoll KLassen für die verwendeten Datentypen die du brauchst und ersetze deine einfachen Datentypen mit den entsprechenden Klassen. Em Ende kannst Du dann durch deine Propertyinstanzen iterieren und die geänderten in allen Geschmacksrichtungen ausgeben.

Gute Idee, manchmal braucht man mal Denkanstöße, da fallen mir gleich noch ein paar Dinge ein, die vereinfacht werden könnten und damit zusammen hängen.

Zitat von Lemmy:

Oder du verwendest Settermethoden und pimpst diese über AOP mit einer entsprechenden Überwachung....

wie würde das funktionieren, ohne jetzt den Rahmen hier zu sprengen? Könnte man sich da wo einlesen?

[Der schöne Günther]

Ich habe grade mal das hier:

Delphi-Quellcode:

program Project11;

{$APPTYPE CONSOLE}

{$R *.res}

uses
  System.SysUtils,
  System.Rtti,
  System.Generics.Defaults,
  Delphi.Mocks.Helpers in 'Delphi.Mocks.Helpers.pas';

type
   TFoo = class(TObject)
      public var
         SomeInt:   Integer;
         SomeString:   String;
      public
         function Clone(): TFoo;
   end;

function TFoo.Clone(): TFoo;
begin
   Result := TFoo.Create();
   try
      Result.SomeInt := SomeInt;
      Result.SomeString := SomeString;
   except
      Result.Destroy(); raise;
   end;
end;


procedure printFieldDifference(const a, b: TFoo);
var
   context: TRttiContext;

   fields:   TArray<TRttiField>;
   field:   TRttiField;
begin
   context := TRttiContext.Create();

   fields := context.GetType(TFoo).GetFields();
   for field in fields do
      if not field.GetValue(a).Equals( field.GetValue(b) ) then begin
         WriteLn('Field "', field.Name, '" is different.');
         WriteLn('a: ', field.GetValue(a).ToString());
         WriteLn('b: ', field.GetValue(a).ToString());
      end;


end;


var
   myInstance: TFoo;
   myBackup:   TFoo;
begin
   myInstance := TFoo.Create();
   myInstance.SomeInt := 42;
   myInstance.SomeString := 'Hallo Welt';

   myBackup := myInstance.Clone();

   // Irgendetwas geschieht...
   myInstance.SomeString := 'Tschüss Welt';
   //myInstance.SomeInt := 99;

   printFieldDifference(myInstance, myBackup);

   myInstance.Destroy();
   myBackup.Destroy();

   readln;
end.

(Delphi Mocks @ https://github.com/VSoftTechnologies...ks.Helpers.pas)
Wird benötigt um die TValue-Felder zu vergleichen


Gibt am Schluss aus welche Felder verändert wurden.

[himitsu]

"bitte keine Getter/Setter, das ist zu umständlich"

Was ist daran zu umständlich?


Klassenvervollständigung und Templates/Live-Templates machen da praktisch alles automatisch.

[Der schöne Günther]

Ich kann es schon etwas verstehen. Vergleiche mal

A) Eine Struktur mit fünf simplen Feldern
B) Eine Struktur mit
- Fünf public Properties
- Zehn private (oder protected virtual) Getter/Setter-Methoden
- Fünf private Felder

Die Struktur die man ehemals mit einem schnellen Blick komplett erfasst hat ist jetzt schon um einiges aufgeblähter. In C# ist das ganze deutlich knackiger formuliert. Alternativ könnte die IDE Dinge wie einen funktionierenden Klassen-Explorer für ein schnelles UML-Diagramm mitbringen. Dann wäre das halb so wild

[sh17]

Zitat von himitsu:

"bitte keine Getter/Setter, das ist zu umständlich"
Was ist daran zu umständlich?
Klassenvervollständigung und Templates/Live-Templates machen da praktisch alles automatisch.

Hab grad noch etwas gelesen, also wenn ich es richtig verstehe, könnte ich es Zugriff auf die Setter-Methode per AOP abfangen und mir den geschriebenen Wert merken? Es geht mir ja nur darum, die ganze Funktionalität des Reagierens auf geänderte Werte aus dem Objekt selbst herauszuhalten, weil es eben selbst nichts damit zu tun haben soll. Es geht hier auch um sehr viele verschiedene Klassen, die ich alle gar nicht anfassen möchte.

Edit: Könnte man eine Art LiveBinding "missbrauchen"?