"Linke Seite kann nicht zugewiesen werden" für Datensatztypeigenschaften in Delphi

Ich bin neugierig, zu wissen, warum Delphi behandelt record type Eigenschaften, als nur zu Lesen:

  TRec = record
    A : integer;
    B : string;
  end;

  TForm1 = class(TForm)
  private
    FRec : TRec;
  public
    procedure DoSomething(ARec: TRec);
    property Rec : TRec read FRec write FRec;
  end;

Wenn ich versuche, das zuweisen eines Wertes zu jedem der Mitglieder der Rec-Eigenschaft, ich werde "Linke Seite kann nicht zugeordnet werden" Fehler:

procedure TForm1.DoSomething(ARec: TRec);
begin
  Rec.A := ARec.A;
end;

während Sie das gleiche mit der darunter liegenden Feld ist erlaubt:

procedure TForm1.DoSomething(ARec: TRec);
begin
  FRec.A := ARec.A;
end;

Gibt es eine Erklärung für das Verhalten?

Hinsichtlich

InformationsquelleAutor der Frage vcldeveloper | 2009-03-06

delphi records

27

Seit "Rec" ist eine Eigenschaft, die der compiler behandelt es ein wenig anders, denn es muss zuerst bewerten Sie das "Lesen" der Immobilie decl. Betrachten Sie diese, was ist semantisch äquivalent zu deinem Beispiel:
```
...
property Rec: TRec read GetRec write FRec;
...
```
Wenn man sich anschaut, wie diese, können Sie sehen, dass die erste Referenz auf "Rec" (vor dem Punkt ('.'), rufen Sie GetRec, die erstellt eine temporäre lokale Kopie von Rec. Diese Provisorien sind by design "nur Lesen." Dies ist, was Sie ausführen in.

Andere Sache, die Sie hier tun können, ist zu brechen, die einzelnen Felder des Datensatzes als Eigenschaften der enthaltenden Klasse:
```
...
property RecField: Integer read FRec.A write FRec.A;
...
```
Dies erlaubt Ihnen die direkte Zuordnung über die Eigenschaft, um das Feld der embedded-Datensatz in der Instanz der Klasse.

InformationsquelleAutor der Antwort Allen Bauer

Ja das ist ein problem. Aber das problem kann behoben werden, mithilfe von Datensatz-Eigenschaften:

type
  TRec = record
  private
    FA : integer;
    FB : string;
    procedure SetA(const Value: Integer);
    procedure SetB(const Value: string);
  public
    property A: Integer read FA write SetA;
    property B: string read FB write SetB;
  end;

procedure TRec.SetA(const Value: Integer);
begin
  FA := Value;
end;

procedure TRec.SetB(const Value: string);
begin
  FB := Value;
end;

TForm1 = class(TForm)
  Button1: TButton;
  procedure Button1Click(Sender: TObject);
private
  { Private declarations }
  FRec : TRec;
public
  { Public declarations }
  property Rec : TRec read FRec write FRec;
end;

procedure TForm1.Button1Click(Sender: TObject);
begin
  Rec.A := 21;
  Rec.B := 'Hi';
end;

Diese kompiliert und arbeitet ohne problem.

InformationsquelleAutor der Antwort Toon Krijthe

8

Den compiler ist, das Sie von der Zuordnung zu einem temporären. Das äquivalent in C# ist erlaubt, aber es hat keine Wirkung; der Rückgabewert der Rec-Eigenschaft wird eine Kopie des zugrunde liegenden Feldes, und die Zuweisung an das Feld in der Kopie ist ein nop.

InformationsquelleAutor der Antwort Barry Kelly

Einer Lösung, die ich Häufig benutze, ist zu erklären, dass die Eigenschaft als Zeiger auf den Datensatz.

type
  PRec = ^TRec;
  TRec = record
    A : integer;
    B : string;
  end;

  TForm1 = class(TForm)
  private
    FRec : TRec;

    function GetRec: PRec;
    procedure SetRec(Value: PRec);
  public
    property Rec : PRec read GetRec write SetRec; 
  end;

implementation

function TForm1.GetRec: PRec;
begin
  Result := @FRec;
end;  

procedure TForm1.SetRec(Value: PRec);
begin
  FRec := Value^;
end;

Mit dabei, direkt zuweisen Form1.Rec.A := MyInteger arbeiten, aber auch Form1.Rec := MyRec wird die Arbeit durch kopieren der Werte in MyRec zu den FRec Feld als erwartet.

Der einzige Fallstrick ist hier, dass, wenn Sie wollen, um tatsächlich abrufen eine Kopie der Aufzeichnung, mit zu arbeiten, müssen Sie etwas, das wie MyRec := Form1.Rec^

InformationsquelleAutor der Antwort vehystrix

Weil Sie implizite getter-und setter-Funktionen und Sie können nicht ändern, das Ergebnis einer Funktion, wie es ist ein const-parameter.

(Hinweis: Im Fall, verwandeln Sie den Datensatz in ein Objekt, das Ergebnis wäre eigentlich ein Zeiger, so entspricht einem var-parameter).

Wenn Sie möchten, bleiben Sie mit einem Datensatz, verwenden Sie eine temporäre variable (oder Variablen) oder die Verwendung einer WITH-Anweisung.

Sehen, die verschiedenen Verhaltensweisen, die in den folgenden code mit dem expliziten getter-und setter-Funktionen:

type
  TRec = record
    A: Integer;
    B: string;
  end;

  TForm2 = class(TForm)
  private
    FRec : TRec;
    FRec2: TRec;
    procedure SetRec2(const Value: TRec);
    function GetRec2: TRec;
  public
    procedure DoSomething(ARec: TRec);
    property Rec: TRec read FRec write FRec;
    property Rec2: TRec  read GetRec2 write SetRec2;
  end;

var
  Form2: TForm2;

implementation

{$R *.dfm}

{ TForm2 }

procedure TForm2.DoSomething(ARec: TRec);
var
  LocalRec: TRec;
begin
  // copy in a local variable
  LocalRec := Rec2;
  LocalRec.A := Arec.A; // works

  // try to modify the Result of a function (a const) => NOT ALLOWED
  Rec2.A := Arec.A; // compiler refused!

  with Rec do
    A := ARec.A; // works with original property and with!
end;

function TForm2.GetRec2: TRec;
begin
  Result:=FRec2;
end;

procedure TForm2.SetRec2(const Value: TRec);
begin
  FRec2 := Value;
end;

InformationsquelleAutor der Antwort François

3

Dies ist, weil die Eigenschaft auch tatsächlich erfüllt eine Funktion. Eigenschaften nur zurückgeben oder festlegen eines Werts. Es ist nicht eine Referenz oder ein Zeiger auf den Datensatz

also :
```
Testing.TestRecord.I := 10;  // error
```
ist der gleiche wie der Aufruf einer Funktion wie folgt:
```
Testing.getTestRecord().I := 10;   //error (i think)
```
was Sie tun können, ist:
```
r := Testing.TestRecord;    // read
r.I := 10;
Testing.TestRecord := r;    //write
```
Es ist ein bisschen chaotisch, aber inhärente in dieser Art von Architektur.

InformationsquelleAutor der Antwort adrianj98
2

Wie andere gesagt haben - das Lesen der Eigenschaft zurück, eine Kopie der Aufzeichnung, so dass die Zuordnung der Felder nicht handeln auf der Kopie, die im Besitz von TForm1.

Eine weitere option ist das etwas wie:
```
  TRec = record
    A : integer;
    B : string;
  end;
  PRec = ^TRec;

  TForm1 = class(TForm)
  private
    FRec : PRec;
  public
    constructor Create;
    destructor Destroy; override;

    procedure DoSomething(ARec: TRec);
    property Rec : PRec read FRec; 
  end;

constructor TForm1.Create;
begin
  inherited;
  FRec := AllocMem(sizeof(TRec));
end;

destructor TForm1.Destroy;
begin
  FreeMem(FRec);

  inherited;
end;
```
Delphi dereferenzieren der PRec-pointer für Sie, so dass Dinge wie diese immer noch funktionieren:
```
Form1.Rec.A := 1234; 
```
Gibt es keine Notwendigkeit für ein schreiben Teil des Grundstücks, es sei denn, Sie wollen die swap-PRec-buffer, FRec Punkte an. Ich wirklich würde nicht empfehlen, solche swapping über eine Immobilie sowieso.

InformationsquelleAutor der Antwort otherchirps

Der einfachste Ansatz ist:

procedure TForm1.DoSomething(ARec: TRec);
begin
  with Rec do
    A := ARec.A;
end;

InformationsquelleAutor der Antwort Nik Todorov

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.