Record Zugriff umleiten...

[Mavarik]

Moin Zusammen...

Ich stehe heute Morgen etwas auf dem Schlauch, daher brauche ich Eure Hilfe.

Folgendes Problem:

Delphi-Quellcode:

type

    TMyData = Record
               A : Shortstring
               B : Integer
               // usw...
             end;
var
  V1,V2 : TMyData;
begin
  // Beispielbenutzungen
  V1 := V2;
  Move(V1,V2,sizeof(V1));
  Blockwrite(f,V1,Sizeof(F));
  // usw.
end.

Ich möchte jetzt aus dem Record eine classe machen um bei jedem Zugriff auf die Variable eine Procedure aufrufen zu können. Habe mir schon die Überladenen Operatoren angesehen. Eine Property hilft leider auch nicht oder doch?



Hat jemand ne Idee?

Mavarik

[mkinzler]

Beim direkten Zugriff auf den Speicher, helfen Properties nicht. Mir wäre auch keine Funktionalität bekannt, welche das so unterstützen würde.

[himitsu]

Klasse: Operatoren gibt es aber derzeit nur für Records. (wobei es für Interfaces technisch auch möglich sein sollte, falls Emba mal irgendwann auf mich hört)

Das Move/BlockWrite/BlockRead kannst du dir höchstens selber implementieren, als Read-/Write-Methode, was man notfalls über die RTTI etwas automatisieren könnte.

[p80286]

das blockwrite ist so ja nicht zugebrauchen, aber warum sollte das mit den Gettern/Settern nicht funktionieren?
Ggf. benutzt man halt Pointer oder hab ich da etwas falsch verstanden?

Gruß
K-H

[mkinzler]

Wenn im Programm der Spicherbereich direkt überschrieben wird, wird der Setter ja nicht aufgerufen.

[Iwo Asnet]

Ich versteh das Problem nicht ganz, denn ich würde eine Assign- btw. AssignTo-Methode implementieren und damit das Problem umgehen.

Oder möchtest Du es kodekompatibel gestalten, um wenig Arbeit bei der Umwandlung von Record->Klasse zu haben? Das würde ich nicht machen, denn dein Code wäre nur sehr schwer zu verstehen. Per definitionem ist eine Zuweisung bei Objekten eine Zeigerzuweisung und keine Kopieroperation.

Oder meinst Du, das Du jeden Lesezugriff auf die Instanz kontrollieren möchtest, quasi einen Getter für 'Self'? Dann verwende vielleicht einen kleinen Wrapper:

Delphi-Quellcode:

Type
  TObjectAccessSentinel = Class
  private
    Function GetObject : TMyObject; // <<--- hier deine Kontrollroutine für den Zugriff
  Public
    Constructor Create (aObject : TMyObject)
    Property Object : TMyObject Read GetObject;
  End;

Du erstellst dann den Wrapper und arbeitest nicht direkt mit (z.B.) V1, sondern mit dem Wrapper.

[Neutral General]

Ich verstehe glaube ich nicht so 100%ig was du genau willst.
Und ich glaube die anderen die bisher geantwortet haben auch nicht so richtig.

Delphi-Quellcode:

TMyData = Record
private
  FText: String;
  function GetText: String;
  procedure SetText(const AValue: String);
public
  property Text: String read GetText write SetText;
end;

// ODER als Klasse:

TMyData = class
private
  FText: String;
  function GetText: String;
  procedure SetText(const AValue: String);
public
  property Text: String read GetText write SetText;
end;

In dem Getter/Setter kannst du dann jeweils irgendetwas tun wenn die Property gelesen oder geschrieben wird.

Die Getter/Setter können allerdings nicht auf soetwas wie

Delphi-Quellcode:

V1 := V2;
Move(V1,V2,sizeof(V1));
Blockwrite(f,V1,Sizeof(F));

reagieren. Da funktioniert es nicht und da gibt es auch keine Lösung das zu realisieren.

Bei Klassen sind die 3 oberen Möglichkeiten des Kopierens ja gar nicht möglich, also erübrigt sich die Frage dafür.

Wenn direkt auf FText zugegriffen wird und quasi dadurch die Property inkl. Getter/Setter umgangen wird, dann bekommen Getter und Setter natürlich auch nichts davon mit.

[Furtbichler]

Vielleicht erklärst Du noch, was Du eigentlich erreichen willst. Mir scheint, Du denkst in diesem Fall vielleicht einen Tick zu kompliziert.

[Mavarik]

Danke erstmal für eure Antworten...

Halten wir mal fest, es gibt keine Lösung!

Grüsse Mavarik

[sx2008]

Zitat von Mavarik:

Halten wir mal fest, es gibt keine Lösung!

Ich würde eher sagen, du hast noch nicht die richtige Ebene der Abstraktion erreicht.
Du klammerst dich an einen Record obwohl es auch wesentlich flexiblere Datenstrukturen gibt.
Nehmen wir z.B. ein Diktionary:

Delphi-Quellcode:

var
  dict, dict2 : TMyDictionary;
begin
  dict := TMyDictionary.Create;
  dict['A'] := 42;
  dict['B'] := 'Teststring';
  dict['Visible'] := True;
 
  // Beispiel für einen Copy-Konstruktor
  dict2 := TMyDictionary.Create(dict);
  // dict2 enthält jetzt alle Daten von dict

  dict2.SaveToFile('data.txt');
  dict2.Free;
  dict.Free;
end;

Indem du dich von einem Record löst und Datenstrukturen auf einer höhere Abstraktionsebene verwendest kannst du mehr erreichen.
Natürlich ist dies immer auch mit einem gewissen Verlust an Geschwindigkeit verbunden, aber das ist meist kaum zu spüren.