auf die Daten der Basisklasse zugreifen

[bernhard_LA]

im Code Fragment unten eine vereinfachte Version meiner Klasendefinitionen. Würde gerne die zu TMyData gehörenden Felder elegant / mit wenig Zeilen Code zuweisen, gibt es eine bessere als meine aktuelle Lösung in Delphi ?

Delphi-Quellcode:

Type  

TMyData = class
     i  : Integer;
     j  : Integer;
     pt  : TPoint;
end;
 

TMyClass= Class(TMyData) 

      Index : Integer;  
end; 


TExtendClass = class ( TMyClass ) 

a : string ; 
b : string ;


procedure LoadDatafromDatabase  ;

end;  




procedure TExtendClass.LoadDatafromDatabase  ;
var  aData  :  TMyData; 
begin
     ///  DAten aus einer Datenbank laden ....
     ladeDaten ( aData   ) ; 

      ///  kann ich diesen länglichen umkopier code vermeiden ?????????
      self.i :=  aData.i;
      self.j :=  aData.j;
      ....

end;

[himitsu]

Delphi-Quellcode:

ladeDaten(Self);

:?:

[SebastianZ]

Wenn Daten über mehrere Klassen hinweg kopiert werden sollen, wäre der Klassiker die Klasse von TPersistent abzuleiten und Assign zu implementieren:
http://docwiki.embarcadero.com/Libra...sistent.Assign

Ansonsten ist die Antwort von himitsu natürlich einfacher ;)


Dein Beispiel (ungetestet) erweitert:

Delphi-Quellcode:

Type 

TMyData = class(TPersistent)
     i : Integer;
     j : Integer;
     pt : TPoint;
  public
    procedure Assign(Source: TPersistent); override;

end;
 

TMyClass= Class(TMyData) 

      Index : Integer; 
end; 


TExtendClass = class ( TMyClass ) 

a : string ; 
b : string ;


procedure LoadDatafromDatabase ;

end; 


procedure TMyData.Assign(Source: TPersistent);
begin
  if Source IS (TMyData) then
  begin
    Self.i := TMyData(Source).i;
    Self.j := TMyData(Source).j;
    ....
  end;
end;


procedure TExtendClass.LoadDatafromDatabase ;
var aData : TMyData; 
begin
     /// DAten aus einer Datenbank laden ....
     ladeDaten ( aData ) ; 

      /// kann ich diesen länglichen umkopier code vermeiden ?????????
      Self.Assign(aData);
end;

[TiGü]

Delphi-Quellcode:

program Project1;

{$APPTYPE CONSOLE}
{$R *.res}

uses
  System.SysUtils,
  System.TypInfo;

type
  TMyClassA = class
  private
    FMyStringA: string;
    FMyIntB: Integer;
  published // <--- wichtig!
    property MyInt: Integer read FMyIntB write FMyIntB;
    property MyString: string read FMyStringA write FMyStringA;
  end;

  TMyClassB = class
  private
    FMyStringB: string;
    FMyIntB: Integer;
  published // <--- wichtig!
    property MyInt: Integer read FMyIntB write FMyIntB;
    property MyString: string read FMyStringB write FMyStringB;
  end;

procedure CopyPropsFromAtoB(A, B: TObject);
var
  PropList: PPropList;
  i, PropCount: Integer;
  PropertyValue: Variant;
  PropertyName: string;
begin
  PropCount := GetPropList(A, PropList);
  if PropCount > 0 then
  begin
    try
      for i := 0 to PropCount - 1 do
      begin
        PropertyName := PropList[i].NameFld.ToString;
        try
          PropertyValue := GetPropValue(A, PropertyName);
          SetPropValue(B, PropertyName, PropertyValue);
        except
          on E: EPropertyConvertError do
          begin
            Writeln(E.ClassName + '.' + E.Message + ' - ' + 'Propertyname: ' + PropertyName);
          end;
          on E: EPropertyError do
          begin
            Writeln(E.ClassName + '.' + E.Message + ' - ' + 'Propertyname: ' + PropertyName);
          end;
          on E: Exception do
          begin
            // Untern Tisch verstecken!
          end;
        end;
      end;
    finally
      FreeMem(PropList);
    end;
  end;
end;

procedure Main;
var
  A: TMyClassA;
  B: TMyClassB;
begin
  A := TMyClassA.Create;
  B := TMyClassB.Create;

  A.MyInt := 666;
  A.MyString := A.MyInt.ToString;

  CopyPropsFromAtoB(A, B);

  Writeln(B.MyInt);
  Writeln(B.MyString);

  A.Free;
  B.Free;
end;

begin
  try
    Main;
    Readln;
  except
    on E: Exception do
      Writeln(E.ClassName, ': ', E.Message);
  end;
end.

[TigerLilly]

:-) Zu COBOL Zeiten gab es ein MOVE CORRESPONDING.

Solltest du mit einer Kanone auf Spatzen schießen wollen, könntest du Properties machen und via RTTI zusammengehörige Felder zuweisen.

Solltest du ganz hässlichen Code produzieren wollen, könntest du überlegen, dass i,j und pt alle am selben Offset im Speicher stehen, du könntest also einfach einen Speicherbereich via Offset und Länge kopieren. 8-)

Im Übrigen sind alle anderen erwähnten Lösungen natürlich viel besser!

Uups. Zwischenzeitlich ist Variante 1 tatsächlich vorgeschlagen worden. Wow.

[TiGü]

Geht gewiss auch mit "neuer" RTTI und dann ohne published-Properties direkt auf die private-Felder.
Aber ich denke du hast jetzt eine Idee in welche Richtung du gucken musst.

Das Ganze ist natürlich witzlos, wenn die Namen zwischen den Klassen verschieden sind.
Du musst dir auch bewusst sein, dass es natürlich länger dauert per RTTI, als die direkte Zuweisung.

[himitsu]

Joar, im normalen Programmieralltag würde ich auf solche "komplexen" (langsamen) Kopierfunktionen auch lieber verzichten wollen.
Nach und von JSON serialisieren stünde da auch noch zur Auswahl. :freak:



PS: TObject ist ein Zeiger auf einen Record.
System.CopyRecord oder System.CopyArray mit Length=1 :stupid:

[TiGü]

Zitat:

Zitat von TigerLilly (Beitrag 1379118)

Uups. Zwischenzeitlich ist Variante 1 tatsächlich vorgeschlagen worden. Wow.

Bei vielen verschiedenen Klassen und den Gebrauch derartiger Zuweisungen kann man die Kanone ruhig nehmen.
Dann fällt auch schnell auf, wenn eine Prop in Klasse A deklariert wurde und nicht in Klasse B.
Sowas wird beim Assign natürlich schnell vergessen.

[TigerLilly]

Zitat:

Zitat von TiGü (Beitrag 1379121)

Bei vielen verschiedenen Klassen und den Gebrauch derartiger Zuweisungen kann man die Kanone ruhig nehmen.

Naja, bei mir läuten bei sowas eher die Alarmglocken + ein Schild mit "Designfehler" poppt auf. So ein blindes im Nebel herumstochern sollte wirklich die Ausnahme sein. Aber man kann natürlich auch ein Maßband zum Fenster rauswerfen + aus der Lautstärke des Aufpralls auf die Fallhöhe rückschließen. Kreativ, funktioniert, nicht jeder wär draufgekommen, aber mit dem Maßband messen wär auch gegangen.

Zitat:

Zitat von TiGü (Beitrag 1379121)

Dann fällt auch schnell auf, wenn eine Prop in Klasse A deklariert wurde und nicht in Klasse B.
Sowas wird beim Assign natürlich schnell vergessen.

Nope. Das ist eher genau umgekehrt. In deinem Code fällt das gar nicht auf. Beim Assign hättest du schon zur Compilierzeit einen Fehler.

[TiGü]

Zitat:

Zitat von TigerLilly (Beitrag 1379130)

Nope. Das ist eher genau umgekehrt. In deinem Code fällt das gar nicht auf. Beim Assign hättest du schon zur Compilierzeit einen Fehler.

Was glaubst du, was passiert, wenn SetPropValue die (neu angelegte) Property von Klasse A in Klasse B nicht findet?

Beim Assign musst du das in der entsprechenden Methode explizit hinschreiben.
Das wird vergessen, sobald mehr als eine Person an der Klassenstruktur herumdoktert.
Nix mit Fehler zur compile time.