Objekt in Liste mit anderer Instanz ersetzen ohne Referenz zu verlieren

[norwegen60]

Hallo zusammen,

ich habe eine

Delphi-Quellcode:

TMyObjectList = class(TObjectList<TMyObject>);

.
Jedes TMyObject hat eine eindeutige ID (ID aus der Datenbank)
Jetzt könnte es sein, dass ich an anderer Stelle bei einer Änderung eine Instanz1.2 bekomme, die schon in der Liste enthalten ist (Instanz1.1).
Da es sein kann, dass irgendwo im Code schon auf Instanz1.1 verwiesen wird (in meinem Fall in zwei TVirtualStringTree), kann ich diese ja nicht einfach in der Liste löschen und dafür Instanz1.2 hinzufügen.
Wie schaffe ich es aber einfach, dass Instanz1.1 die eventuell aktuelleren Daten aus Instanz1.2 übertragen bekommt?

Grüße
Gerd

[mkinzler]

Mit .Assign() kann man Werte von einem Objekt auf das andere übertragen.

Delphi-Quellcode:

<Instanz1.1>.Assign( <Instanz1.2>);

[himitsu]

Aber nur wenn Assign/AssignTo implementiert ist.

Aber das Prinzip stimmt schonmal ... du mußt den Inhalt von 2 in die 1 kopieren / ihr zuweisen ... und sei es, dass du es mit jedem Feld/Property einzeln machen mußt.

[norwegen60]

Zitat:

Zitat von himitsu (Beitrag 1518385)

Aber nur wenn Assign/AssignTo implementiert ist.

Aber das Prinzip stimmt schonmal ... du mußt den Inhalt von 2 in die 1 kopieren / ihr zuweisen ... und sei es, dass du es mit jedem Feld/Property einzeln machen mußt.

Genau das war es was ich befürchtet habe und nach einer einfacheren Lösung gesucht habe :cry:
OK, in dem gerade aufgetretenen Fall sind es nur 5 Felder, die sich ändern können und damit ist die Implementation von Assign überschaubar. Es ging mir aber ums generelle

[mkinzler]

Um was für Objekte hanldet es sich? Wenn es eigene Klassen sind einfach Assign für diese implementieren.

[norwegen60]

Meine Klasse sieht prinzipiell so aus. Hier schon mit dem Assign, wie ich es verstanden hätte

Delphi-Quellcode:

  
  TMyBaseClass = class;
  private
    FID:Integer;
    FName: String;

    procedure SetID(const Value: Integer);
    procedure SetName(const Value: String);
  public
    property ID: Integer read FID write SetID;
    property Name: String read FName write SetName;

    constructor Create;
    destructor Destroy; override;

    procedure Assign(aNewValue:TMyBaseClass);         

    function FunctionB1: String;         
    procedure ProcB1(sMsg: String); 
  end;

  TMyClass = class(TMyBaseClass);
  private
    FInfo:String;

    procedure SetInfo(const Value: String);
  public
    property Info: String read FInfo write SetInfo;

    constructor Create;
    destructor Destroy; override;

    procedure Assign(aNewValue:TMyClass);         
    function Function10: String;         
    procedure Proc10(sMsg: String); 
  end;

..

Procedure TMyBaseClass.Assign(aNewValue:TMyBaseClass);
begin
  self.ID := aNewValue.ID; // Und damit Möglichkeit, TMyClass komplett zu überschreiben
  self.Name := aNewValue.Name;
end;
  

Procedure TMyClass.Assign(aNewValue:TMyClass);
begin
  inherited (TMyBaseClass(aNewValue));

  self.Info := aNewValue.Info;
end;

Oder geht das einfacher?

Mein Problem ist, dass TMyClass aus ca. 40 Properties besteht und noch Unter- und Überklassen bestehen. Nur Arbeit, alle Properties in Assign aufzunehemen, aber schwierig, den aktuelle zu halten wenn mehrere eventuell neue Properties hinzufügen (Selten, aber kann vorkommen)

[himitsu]

Anders geht es nunmal nicht (effektiv).

Man kann ab TPersistent vererben und dort das Streaming missbrauchen
oder via RTTI alles suchen und kopieren.




Bei sowas, wo man etwas mal vergessen könnte, kann man auch

Delphi-Quellcode:

{$IF SizeOf(TMyRecord) <> 123} {$MESSAGE Error '...'} {$IFEND}

Bei Klassen ist das leider nicht ganz so einfach, direkt im Compiler, daher wohl eher

Delphi-Quellcode:

if Self.InstanceSize <> 123 then raise ...;

[edit] Kannst auch mal nachsehn, wo sich die InstanceSize in der TypeInfo versteckt.

Das in dein Assign und 123 auf den aktuellen Wert setzen.
-> neues Feld = Peng

[norwegen60]

War mir nicht sicher ob Markus mit

Zitat:

Wenn es eigene Klassen sind einfach Assign für diese implementieren.

nicht noch was einfacheres gemeint hat

[himitsu]

Nein.

TPersistent.Assign und seine Freunde sind doof und wissen von nichts.
Ob man nun extern jedes Feld/Property kopiert, oder in einer Methode ala Assign macht ... gemacht werden muß es so oder so.

Sie können es auch garnicht, da sie nicht wissen was und wie es kopiert werden muß, sobald es keine einfachen Typen sind.

[mkinzler]

Wenn das in allen Klassen implemnetiert ist, musst Du ja nur für die "neuen" Eigenschaften implementieren

Delphi-Quellcode:

TBasis = class
 a,b: Integer;
 procedure Assign( Source: TPersistent); virtual;
end;

TTeil = class 
  aa, zz: integer;
  procedure Assign( Source: TPersistent); virtual;
end;

TAbg = class( TBasis)
  c: TTeil;
  d, e: Integer;
  procedure Assign( Source: TPersistent); virtual;
end;
...
procedure TBasis.Assign( Source: TPersistent); 
begin
  a := Source.a;
  b := Source.b;
end;
...
procedure TTeil.Assign( Source: TPersistent); 
begin
  aa := Source.aa;
  zz := Source.zz;
end;
...
procedure TAbg.Assign( Source: TPersistent); 
begin
  inherited Assign( Source); //a, b
  c.Assign( Source.c); //c
  d := Source.d;
  e := Source.e;
end;

[norwegen60]

Danke für eure Tips. Ich habe bestätigt bekommen, was ich so zu wissen geglaubt habe, aber trotzdem nochmal absichern wollte.

Bei vielen Properties wird leider aus dem "nur nur für die "..neuen" Eigenschaften..." etwas mehr und es geht eher um die laufenden Pflege. Dass jeder auch daran denkt dass da noch ein Assign gepflegt werden muss.

Ein klein bisschen hatte ich die Hoffung, dass es irgendwo noch eine Möglichkeit gibt, den Zeiger auf Instanz1.1 so zu ändern, dass er auf Instanz1.2 weiter leitet.

[himitsu]

Delphi-Quellcode:

TAbg = class(TBasis)
  procedure Assign(Source: TPersistent); {virtual;} overload;

:angle:

Zitat:

Zitat von norwegen60 (Beitrag 1518398)

Ein klein bisschen hatte ich die Hoffung, dass es irgendwo noch eine Möglichkeit gibt, den Zeiger auf Instanz1.1 so zu ändern, dass er auf Instanz1.2 weiter leitet.

Naja, PObject sowie PPointer
aber nja.

oder ein Objekt im Object, wo sich das innere Objekt tauschen lässt.

[norwegen60]

Zitat:

Zitat von himitsu (Beitrag 1518399)

Delphi-Quellcode:

TAbg = class(TBasis)
  procedure Assign(Source: TPersistent); {virtual;} overload;

Ich habe meine Assign aktuell nicht mit Virtual und Overload versehen, konnte aber nicht feststellen, dass etwas nicht geht und Compilerwarnung gabs auch keine.
Nur unsauber oder falsch?

[Uwe Raabe]

Das Delphi-eigene Assign ist in TPersistent deklariert und bildet somit schon mal ein Grundgerüst. Dort sind Assign und AssignTo virtual deklariert und können dann in abgeleiteten Klassen überschrieben und mit Leben gefüllt werden. Da deine Klassen nicht von TPersistent abgeleitet sind, hast du da natürlich freie Wahl.

[himitsu]

Dort war nur "falsch", dass es in TBasis virtual war und im Nachfahren nochmal virtual,
also verdeckt, anstatt überschrieben.

[norwegen60]

Das zweimalige Virtual hatte ich nach deinem Hinweis gesehen. Nur bei der generelle Verwendung war ich mir unsicher.

[joachimd]

ich habe mir jetzt nicht alle Vorschläge durchgelesen...aber wären Interfaces nicht dafür geeignet? Das Objekt wird erstellt, einer Interface-Variablen zugeordnet, in der anderen Liste einer anderen Interface-Variablen zugeordnet usw...bei Änderung des Objekts ist es dann in allen Instanzen sichtbar.

[stahli]

Ich habe (wenn ich das Problem richtig verstehe) in einem ähnlichen Fall einen Pool eingerichtet, der meine Objektinstanzen verwaltet - jede Instanz einmalig.
In buisinessbezogenen Listen werden dann nur Referenzen auf diese Objekte verwaltet (statt TObjectList dann entsprechend TList verwenden).

Drei Zugriffsmöglichkeiten sehe ich:
- direkter Zugriff auf Objktinstanzen
- Zugriff über Interfaces
- Zugriff über Guids (der Pool muss dann eine binäre Suche unterstützen)

[norwegen60]

Hallo zusammen,

für mich ist der Thread gelöst.
Umstellung auf Instanzen oder Pooling sind aktuell keine Lösung. Die Anwendung ist zu umfangreich und damit der Eingriff zu groß.

Mein Problem wäre schon damit gelöst, wenn der Teil, der die Änderung vornimmt, auch auf die Liste zugreifen würde. Dann hätte ich gar keine zwei Instanzen. Aber auch das bedeutet Zeit die ich momentan nicht habe.

Da war die Synchronisation der notwendigen Felder per Assign schneller implementiert

Danke an alle
Gerd