Daten zwischen Klassen übertragen (mit RTTI?)

[lowmax_5]

Hallo,

ich habe zwei verschiedene Klassen, wo einige Properties identisch sind.
MyClass1 enthält diverse Properties, MyClass2 nur eine Teilmenge davon.
Ich möchte nun bestimmte Werte aus der einer Klasse in die andere kopieren, die in beiden Klassen denm gleichen Propertynamen haben. Dieses mache ich mit:

Code:

MyClass1.nr:=MyClass2.nr;
MyClass1.name:=MyClass2.name;
MyClass1.vorname:=MyClass2.vorname;
MyClass1.TelNr:=MyClass2.TelNr;

Diese vorhendweise scheint mir zu mühsam und auch unelegant, da ich jeden Wert über den Namen ansprechen muss.

Gibt es z.B. mittels Rtti die Möglichkeit alle gleichnamigen properties von MyClass2 in MyClass1 zu kopieren, ohne diese direkt mit Ihrem Namen anzusprechen?

[Benedikt Magnus]

Wenn die eine Klasse eine Untermenge der anderen darstellt, könntest du die größere von der kleineren Klasse ableiten. Dann müsste ein einfaches Zuweisen genügen.

[himitsu]

Zitat:

Delphi-Quellcode:

MyClass1.nr:=MyClass2.nr;
MyClass1.name:=MyClass2.name;
MyClass1.vorname:=MyClass2.vorname;
MyClass1.TelNr:=MyClass2.TelNr;

Das ist eigerntlich richtig, aber wenn man das öfters macht, dann darf man diesen Code auch gern in die Assign-Methode seiner Klassen verlagern. (von TPersistent oder TComponent geerbt)
TPersistent.Assign und TPersistent.AssignTo

Property Inhalt/Einstellungen von SL1 in SL2 übernehmen:

Delphi-Quellcode:

var
  SL1: TStrings;
  SL2: TStringList;

...
SL2.Assign(SL1);

[lowmax_5]

Zitat:

Wenn die eine Klasse eine Untermenge der anderen darstellt, könntest du die größere von der kleineren Klasse ableiten. Dann müsste ein einfaches Zuweisen genügen.

Ich versuche

Code:

type
TmyClass2=Class
  Nr:Integer;
  Name:string;
  Vorname:string;
  Telnr:string;
end;


type
TmyClass1=Class(TmyClass2)
  PLZ:string;
  FremdNr:Integer;
end;

und bekomme bei

Code:

... MyClass1:=myClass2; ...

die Meldung 'Incompatible Typen'

[lowmax_5]

Bei

MyClass2.Assign(MyClass1);

steht mir Assign nicht zur Verfügung. Habe ich hier die Klasse falsch definiert?

Code:

var
  SL1: TStrings;
  SL2: TStringList;

...
SL2.Assign(SL1);

[himitsu]

Etweder man schreibt 'ne Eigene Methode, die sich "Assign" nennt,
oder die Klassen müssen Nachfahren von TPersistent oder TComponent sein, wo man deren Assign überschreibt und die Zuweisungen seiner Property da rein baut.

Delphi-Quellcode:

type 
  TMyClass1 = class(TPersistent)
    ...
    procedure Assign(Source: TPersistent); override;
  end;
  TMyClass2 = class(TMyClass1) // oder class(TPersistent) wenn nicht voneinander abgeleitet
    ...
    procedure Assign(Source: TPersistent); override;
  end;

procedure TMyClass1.Assign(Source: TPersistent);
begin
  inherhited;
  if Source is TMyClass1 then begin
    PropA := TMyClass1(Source).PropA;
    PropB := TMyClass1(Source).PropB;
    ...
  end;
//  if Source is TMyClass2 then begin  // dass auch noch, wenn nicht voneinander abgeleitet
//    PropA := TMyClass2(Source).PropA;  // wobei es dann doch besser in TMyClass2.AssignTo rein gehören würde
//    PropB := TMyClass2(Source).PropB;
//  end;
end;

procedure TMyClass2.Assign(Source: TPersistent);
begin
  inherhited;
  if Source is TMyClass1 then begin
    PropA := TMyClass1(Source).PropA;
    PropB := TMyClass1(Source).PropB;
    ...
  end;
  if Source is TMyClass2 then begin
    //PropA := TMyClass2(Source).PropA;  // dass auch noch, wenn nicht voneinander abgeleitet
    //PropB := TMyClass2(Source).PropB;
    PropC := TMyClass2(Source).PropC;
    ...
  end;
end;

Wenn man Published-Property kopieren will, kann man auch die Serialisierungsfunktionen von TPersistent verwenden, also die MyClass1 in 'nen Stream speichern und MyClass2 aus dem TSream laden, aber zum "Kopieren" wäre es wie mit Kanonen auf Spatzen...

[HolgerX]

Dadurch das die abgeleitete Klasse im Assign 'inherited' aufruft, werden alle Daten kopiert, welche in der jeweiliger Klasse vorhanden sind.

Somit kopiert jede Klasse nur ihre Teilmenge...

Delphi-Quellcode:

type
  TMyClass1 = class(TPersistent)
  public
    Nr        : Integer;
    NachName  : string;
    Vorname   : string;
    Telnr     : string;
    procedure Assign(Source: TPersistent); override;
  end;

  TMyClass2=Class(TMyClass1)
  public
    PLZ       : string;
    FremdNr   : Integer;
    procedure Assign(Source: TPersistent); override;
  end;

implementation

{ TMyClass1 }

procedure TMyClass1.Assign(Source: TPersistent);
begin
  inherited;
  if Source is TMyClass1 then
    Nr      := TMyClass1(Sender).Nr;
    NachName:= TMyClass1(Sender).NachName;
    Vorname := TMyClass1(Sender).Vorname;
    Telnr   := TMyClass1(Sender).Telnr;
  end;
end;

{ TMyClass2 }

procedure TMyClass2.Assign(Source: TPersistent);
begin
  inherited;
  if Source is TMyClass2 then
    PLZ     := TmyClass2(Sender).PLZ;
    FremdNr := TmyClass2(Sender).FremdNr;
  end;
end;

[DeddyH]

Das mit dem inherited wird aber so nicht funktionieren, zumindest in neueren Delphi-Versionen. Da ruft TPersistent.Assign intern TPersistent.AssignTo auf, welches nur einen Fehler wirft und sonst nichts tut. Daraus folgt, dass man inherited nur dann aufruft, wenn die beiden Klassen nicht kompatibel sind.

[HolgerX]

Dann drehen wir das Um:

Delphi-Quellcode:

type
  TMyClass1 = class(TPersistent)
  public
    Nr        : Integer;
    NachName  : string;
    Vorname   : string;
    Telnr     : string;
    procedure AssignTo(Dest: TPersistent); override;
  end;

  TmyClass2 = Class(TMyClass1)
  public
    PLZ       : string;
    FremdNr   : Integer;
    procedure AssignTo(Dest: TPersistent); override;
  end;

implementation

{ TMyClass1 }

procedure TMyClass1.AssignTo(Dest: TPersistent);
begin
//  inherited; Nicht da ja TPersistent.AssignTo anscheinend nen Error wirft...
  if Dest is TMyClass1 then begin
    TMyClass1(Dest).Nr := self.Nr
    TMyClass1(Dest).NachName := self.NachName;
    TMyClass1(Dest).Vorname := self.Vorname;
    TMyClass1(Dest).Telnr := self.Telnr;
  end;
end;

{ TMyClass2 }

procedure TMyClass2.AssignTo(Dest: TPersistent);
begin
  inherited;
  if Dest is TMyClass2 then begin
    TMyClass2(Dest).PLZ := self.PLZ;
    TMyClass2(Dest).FremdNr := self.FremdNr
  end;
end;

Statt Assign zu Überschreiben, nehmen wir halt AssignTo...

Wobei MyClass2.Assign(AMyClass2) sehr wohl alle Daten (PLZ/FremdNr aus TMyClass2 und Nr/NachName/Vorname/Telnr aus TMyClass1) von AMyClass2 nach MyClass2 kopiert hätte...

Und MyClass1.Assign(AMyClass2) würde nur Nr/NachName/Vorname/Telnr kopieren, jedoch PLZ/FremdNr aus TMyClass2 ignorieren..

[lowmax_5]

Vielen Dank für die Antworten. Das 'Assign' löst das Problem für mich jedoch nicht.
Hintergrund: TmyClass2 wird z.B. erweitert und ich muss in der Folge die Assign-funktion dann für das neue Property auch erweitern.
Diesen Schritt hätte ich mir gerne gespart, so dass gleichnamige Properties erkannt und zugewiesen werden. Somit bräuchte dann nur TmyClass2 erweitert werden und das 'Assign' würde automatisch auch das neue Property kopieren.

[DeddyH]

Geht es hiermit?

Delphi-Quellcode:

uses System.Rtti;

...

procedure TDeineKlasse.AssignProps(Source: TObject);
var
  ctxSrc: TRttiContext;
  ctxDest: TRttiContext;
  rtSrc: TRttiType;
  rtDest: TRttiType;
  propSrc: TRttiProperty;
  propDest: TRttiProperty;
begin
  ctxSrc := TRttiContext.Create;
  try
    ctxDest := TRttiContext.Create;
    try
      rtSrc := ctxSrc.GetType(Source.ClassType);
      rtDest := ctxDest.GetType(ClassType);
      for propSrc in rtSrc.GetProperties do
        begin
          propDest := rtDest.GetProperty(propSrc.Name);
          if Assigned(propDest) and
            (propDest.PropertyType = propSrc.PropertyType) then
            if propDest.IsWritable then
              propDest.SetValue(self, propSrc.GetValue(Source));
        end;
    finally
      ctxDest.Free;
    end;
  finally
    ctxSrc.Free;
  end;
end;

Mein Originalcode sieht etwas anders aus, daher kann es sein, dass es nicht auf Anhieb funktioniert.

[lowmax_5]

Super, dass funktioniert! :thumb:

Code:

 MyClass1.AssignProps(myClass2);

Könnte man anstatt auf die Properties auf dem gleichen Weg auch auf die (privaten) Variablen zugreifen?

[DeddyH]

Ganz ehrlich: keine Ahnung. Du könntest es aber mal mit GetFields etc. versuchen.

[Stevie]

Urgs, bitte nicht über RTTI, die blind einfach alles rüberschaufelt. Damit handelt man sich bloß Probleme ein.

Leite die Klasse wie bereits erwähnt von TPersistent ab und benutz das bewährte Verfahren mit Assign/AssignTo.

[SebastianZ]

Alternativ könnte man es auch über einen Record abdecken:

Delphi-Quellcode:

  TMyRec = record
    Data1: String;
    Data2: Integer;
  end;

  TMyClass1 = class
  public
    Data: TMyRec;
    constructor Create;

    property Data1: String read Data.Data1 write Data.Data1;
    property Data2: Integer read Data.Data2 write Data.Data2;
  end;

  TMyClass2 = class(TMyClass1)
  end;

Delphi-Quellcode:

..
  myC1 := TMyClass1.Create;
  myC2 := TMyClass2.Create;
  try

    myC1.Data1 := 'myC1';
    myC2.Data := myC1.Data; //damit wird der Record kopiert
    
    myC1.Data1 := 'was anderes';

  finally
    myC2.Free;
    nyC1.Free;
  end;

Mit diesem Record kann man dann jede Klasse ausstatten, die diese Eigenschaften haben soll.

[einbeliebigername]

Hallo,

Zitat:

Zitat von DeddyH (Beitrag 1350607)

Das mit dem inherited wird aber so nicht funktionieren, zumindest in neueren Delphi-Versionen.

Das ist fast richtig. Nur es war schon immer so und nicht erst in neueren Delphi Versionen.

Zitat:

Zitat von DeddyH (Beitrag 1350607)

Da ruft TPersistent.Assign intern TPersistent.AssignTo auf, welches nur einen Fehler wirft und sonst nichts tut.

Das würde ich präziser ausdrücken.

Delphi-Quellcode:

TPersistent.Assign(Source: TPersistent)

ruft

Delphi-Quellcode:

Source.AssignTo(Self)

auf. Und die Implementierung von AssignTo in TPersistent wirft eine Exception.

Zitat:

Zitat von DeddyH (Beitrag 1350607)

Daraus folgt, dass man inherited nur dann aufruft, wenn die beiden Klassen nicht kompatibel sind.

Nicht ganz richtig. Das inherited ruft man auf, wenn die Basisklasse das übergebene Objekt behandeln kann und wenn man das übergebene Objekt nicht behandeln will. Also so:

Delphi-Quellcode:

type
  TMyClass1 = class(TPersistent)
  public
    Nr : Integer;
    NachName : string;
    Vorname : string;
    Telnr : string;
    procedure Assign(Source: TPersistent); override;
  end;

  TMyClass2=Class(TMyClass1)
  public
    PLZ : string;
    FremdNr : Integer;
    procedure Assign(Source: TPersistent); override;
  end;

implementation

{ TMyClass1 }

procedure TMyClass1.Assign(Source: TPersistent);
begin
  if Source is TMyClass1 then
    Nr := TMyClass1(Sender).Nr;
    NachName:= TMyClass1(Sender).NachName;
    Vorname := TMyClass1(Sender).Vorname;
    Telnr := TMyClass1(Sender).Telnr;
  end
  else
    inherited;
end;

{ TMyClass2 }

procedure TMyClass2.Assign(Source: TPersistent);
begin
  if Source is TMyClass2 then
    inherited;
    PLZ := TmyClass2(Sender).PLZ;
    FremdNr := TmyClass2(Sender).FremdNr;
  end
  else
    inherited;
end;

Und AssignTo überschreibt man, wenn man in der Zielklasse keine Änderung vornehmen kann oder in der Zielklasse die Quellklasse nicht zur Verfügung hat.

einbeliebigername.