Array Properties

[Rabenrecht]

Fühle mich wie ein Programmieranfänger... :(

Ich habe Schwierigkeiten mit dynamischen Array Properties umzugehen.

Habe mich an das hier gehalten: https://docwiki.embarcadero.com/RADS...ray_Properties

Delphi-Quellcode:

type
  TMeineKlasse1 = class(TObject)
  private
    FMeinArray : Array of AndereKlasse;
    funtion Get(Index: Integer):AndereKlasse;
    procedure Set(Index: Integer; Value: AndereKlasse);
  public
    property MeinArray[Index: Integer] : AndereKlasse read Get write Set;
  end;

Jetzt habe ich aber Problem auf das Array an sich zuzugreifen. Zb. um die Länge zu setzen. Zugriffe auf die Property MeinArray verlangen jetzt immer eine Index.
SetLength(MeinArray, x) ist so nicht möglich.

Was muss ich anders machen?

[himitsu]

Dafür erstellst du dir dann ein Property oder Funktion, welche einen Integer zurück gibt.

Delphi-Quellcode:

  public
    function Count: Integer;  // property Count: Integer read GetCount;
    property MeinArray[Index: Integer] : AndereKlasse read Get write Set;
  end;

Beispiele zum Abgucken: TStrings/TStringList, TList usw.

oder

Delphi-Quellcode:

  private
    FMeinArray : TArray<AndereKlasse>;
  public
    property MeinArray: TArray<AndereKlasse> read FMeinArray write FMeinArray;

[Rabenrecht]

Ah, die Variante mit TArray sieht gut aus :-)

Nun bekomme ich bei Aufruf von SetLength(MeinArray, x) den Fehler: "Konstantenobjekt kann nicht als Var-Parameter weitergeben werden"

[KodeZwerg]

Wenn du es als type außerhalb definierst hast du es innerhalb leichter.

Delphi-Quellcode:

type
  TDasArray = array of irgendwas;

  TDieKlasse = class
  strict private
    FDasArray: TDasArray;
  public
    property DasArray: TDasArray read FDasArray write FDasArray;
  end

[himitsu]

Zitat:

Zitat von KodeZwerg (Beitrag 1513812)

Wenn du es als type außerhalb definierst hast du es innerhalb leichter.

Ja,

Delphi-Quellcode:

array of ...

deklariert jedes mal einen neuen Typ und untereinander sind diese Typen nicht zuweisungskompatibel,

Den fertigen Typ vorher deklariert, löst Propbleme, bezüglich der Kompatibilität.
Für String, Byte und Anderes gibt es bereits vordefinierte Typen, ala TBytes oder TStringDynArray.

ABER der generische Type TArray<> ist hier eine Ausnahme, da der Compiler alle TArray<> vom selben Typ im Programm gleichzieht.

Delphi-Quellcode:

// siehe System.pas

type
  TArray<T> = array of T;

Ja, SetLength will eine Variable, aber das ist ja ein Property.
Du mußt das also in der Klasse machen,
oder kein Property verwenden, sondern das Feld/Variable "FMeinArray" ins Public. :freak:

Delphi-Quellcode:

  public
    function Length: Integer; 
    procedure SetLength(Len: Integer;) 
    property Items[Index: Integer] : AndereKlasse read GetItem write SetItem; default;  // kann auch sein, dass ohne das ; vor dem default
  end;

oder

Delphi-Quellcode:

  public
    property Length: Integer read GetLength write SetLength;
    property Items[Index: Integer] : AndereKlasse read GetItem write SetItem; default;
  end;

PS: DEFAULT;
Dann geht auch

Delphi-Quellcode:

MeineKlasse1[123]

anstatt

Delphi-Quellcode:

MeineKlasse1.MeinArray[123]

.
Ja, die Default-Directive hat bei Array-Property eine andere Bedeutung, wie für normale Property.


PSS:

Delphi-Quellcode:

  TMeineKlasse1 = class(TObjectList<AndereKlasse>)
  private
  public
  end; 

  // oder wenn ohne eigenen Code
  TMeineKlasse1 = TObjectList<AndereKlasse>;

[Rabenrecht]

Puh, eigene Klassen drum herum bauen nur um ordentlich drauf zugreifen zu können, klingt jetzt auch nicht so attraktiv. Von daher...

Zitat:

Zitat von himitsu (Beitrag 1513818)

oder kein Property verwenden, sondern das Feld/Variable "FMeinArray" ins Public. :freak:

... werde ich einfach das^^ machen ;-)

Und hoffen, das der Json Serializer auch public Fields "mitnimmt".
Json Serialization ist der einzige Grund, warum ich hier überhaupt mit Arrays rumhühnere, anstatt einfach (Object)Listen zu nutzen.

[Blup]

Im Normalfall würde man kein Array sondern eher eine TObjektList verwenden:

Delphi-Quellcode:

type
  TAndereKlasseList = TObjectList<TAndereKlasse>;

  TMeineKlasse1 = class(TObject)
  private
    FItems: TAndereKlasseList;
  public
    property Items: TAndereKlasseList read FItems; default; {default: statt MeineKlasse.Items[i] kann man direkt MeineKlasse[i] schreiben}
    constructor Create;
    destructor Destroy; override;
  end;

implementation

constructor TMeineKlasse1.Create;
begin
  inherited;
  FItems := TAndereKlasseList.Create;
end;

destructor TMeineKlasse1.Destroy;
begin
  FItems.Free;
  inherited;
end;

[Uwe Raabe]

Zitat:

Zitat von Rabenrecht (Beitrag 1513824)

Json Serialization ist der einzige Grund, warum ich hier überhaupt mit Arrays rumhühnere, anstatt einfach (Object)Listen zu nutzen.

Siehe da: Serializing Generic Object Lists with TJson

[Rabenrecht]

Zitat:

Zitat von Blup (Beitrag 1513828)

Im Normalfall würde man kein Array sondern eher eine TObjektList verwenden:

Jo, ich weiß. Aber siehe meinen Kommentar bzgl. Json Serialisierung :-(

Zitat:

Zitat von Uwe Raabe (Beitrag 1513830)

Siehe da: Serializing Generic Object Lists with TJson

Jo Uwe, deinen Beitrag hab ich schon seit gestern als Tab offen :)
Aber mir schien es einfacher, meine Datenstrukturen auf Arrays umzustellen als den Json Serializer händisch aufzubohren.
Dass ich jetzt auch mit den Arrays ein paar Probleme hatte, war etwas unerwartet :D

[himitsu]

@Blubb

Zitat:

Delphi-Quellcode:

    property Items: TAndereKlasseList read FItems; default; {default: statt MeineKlasse.Items[i] kann man direkt MeineKlasse[i] schreiben

Njain.

Da das hier nun ein "normales" Property ist, hat Default wieder die andere Bedeutung.
Dieses Items bekommst so nicht weg, aber das Default am Items in der Objektlist bekommst'e damit weg, bzw. das ist schon weg.

Delphi-Quellcode:

MeineKlasse.Items[i]

anstatt

Delphi-Quellcode:

MeineKlasse.Items.Items[i]

Das erste Items geht nur weg, wenn es selber ein ArrayProperty ist, also z.B. die Klasse vom TObjekt geerbt, bzw. selber dort das Array implementiert.