Daten zwischen Klassen übertragen (mit RTTI?)

[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.

[einbeliebigername]

Hallo,

Zitat von DeddyH:

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 von DeddyH:

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. TPersistent.Assign(Source: TPersistent) ruft Source.AssignTo(Self) auf. Und die Implementierung von AssignTo in TPersistent wirft eine Exception.

Zitat von DeddyH:

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.