ObjectList serialisieren JSON

[lxo]

Hallo zusammen,

ich hab mit Hilfe des Beitrags von Uwe Raabe probiert eine Objectlist zu de/serialisieren.
Serialisieren klappt aber deserialisieren klappt nicht.

Im TObjectListInterceptor<T>.ObjectsReverter knallt es immer mit einer Zugriffsverletzung.
Kann mir jemand sagen was ich da falsch mache?
List ist immer nil, ich hätte gedacht mit JSONOwned(False) umgeht man das.

https://www.uweraabe.de/Blog/2020/03...ts-with-tjson/

Delphi-Quellcode:

  TPerson = class
  private
   FName: String;
  public
   property Name: String read FName write FName;
  end;

  TPersonListe = TObjectList<TPerson>;

  TPersonListeInterceptor = TObjectListInterceptor<TPerson>;

  type
  TPersonJSON = class
   private
    [JSONOwned(False), JsonObjectList(TPersonListeInterceptor)]
    FPersonListe: TPersonListe;
   public
    constructor Create;
    destructor Destroy; override;
    property PersonListe : TPersonListe read FPersonListe write FPersonListe;
  end;

var
  Form78: TForm78;

implementation

{$R *.dfm}

procedure TForm78.Button1Click(Sender: TObject);
const
  cNamen: TArray<String> = [ 'Name1', 'Name2', 'Name3'];
var
  lPersonJSON : TPersonJSON;
  lPerson : TPerson;
  lReverseTest: TPersonJSON;
  lJSONString: String;
begin
  lPersonJSON := TPersonJSON.Create;
  try
    for var lName in cNamen do
    begin
      lPerson := TPerson.Create;
      lPerson.Name := lName;
      lPersonJSON.PersonListe.Add( lPerson);
    end;

    lJSONString := TJson.ObjectToJsonString( lPersonJSON);
  finally
    lPersonJSON.Free;
  end;

 // !! Hier krieg ich eine Zugriffsverletzung
  lReverseTest := TJson.JsonToObject<TPersonJSON>( lJSONString);
end;

{ TPersonJSON }

constructor TPersonJSON.Create;
begin
  inherited;
  FPersonListe := TPersonListe.Create( True);
end;

destructor TPersonJSON.Destroy;
begin
  FreeAndNil( FPersonListe);
  inherited;
end;

[Uwe Raabe]

Ich vermute mal, du bekommst beim Compilieren diese Meldung?

Zitat:

W1074 Unbekanntes benutzerdefiniertes Attribut

Dann fehlt in deiner Uses-Anweisung noch ein REST.Json.Types. Dort ist JSONOwned nämlich definiert.

[lxo]

Zitat:

Zitat von Uwe Raabe (Beitrag 1497339)

Ich vermute mal, du bekommst beim Compilieren diese Meldung?

Zitat:

W1074 Unbekanntes benutzerdefiniertes Attribut

Dann fehlt in deiner Uses-Anweisung noch ein REST.Json.Types. Dort ist JSONOwned nämlich definiert.

Ja mit REST.Json.Types in der Uses-Anweisung funktioniert es.
Aber die Meldung die du vermutest bekomme ich nicht. Nur eine Zugriffsverletzung beim deserialisieren.

[lxo]

Zitat:

Zitat von lxo (Beitrag 1497345)

Aber die Meldung die du vermutest bekomme ich nicht. Nur eine Zugriffsverletzung beim deserialisieren.

Entschuldigung, doch ich kriege die eine Warnung. "[dcc32 Warnung] Unit78.pas(36): W1074 Unbekanntes benutzerdefiniertes Attribut"
Dachte du meintest eine Fehlermeldung vom Compiler.

[Uwe Raabe]

Ob das als Warnung oder Fehler kommt kannst du in den Projektoptionen unter Erzeugen - Delphi-Compiler - Hinweise und Warnungen - Ausgabewarnungen - Unbekanntes benutzerdefiniertes Attribut durch setzen des Werts auf True bzw. Fehler steuern.

Leider geht das aktuell nur projektweise.

[lxo]

Noch eine Frage hätte ich dazu.
Sehe ich das richtig das man nicht drum rum kommt, eine weitere Klasse zu erstellen die dann die ObjectList enthält? Also wie in meinem Fall die Klasse TPersonJSON?

[Uwe Raabe]

Ja, das ist richtig. Ein JSON String, der nur aus der Liste besteht, stellt halt eine TJSONArray dar und kein TJSONObject. TJson.JsonToObject arbeitet aber nur mit einem TJSONObject.

[haentschman]

Moin...:P

ich hätte noch eine Variante für komplexe Objekte mit Listen <Txxx>: :wink:

Delphi-Quellcode:

class function TToolsJson.JsonFromObject(aValue: TObject): string;
var
  MarshalObj: TJSONMarshal;
  JSONObject: TJSONObject;
begin
  Result := '';
  MarshalObj := TJSONMarshal.Create;
  try
    JSONObject := MarshalObj.Marshal(aValue) as TJSONObject;
    try
      if Assigned(JSONObject) then
        Result := JSONObject.ToString;
    finally
      JSONObject.Free;
    end;
  finally
    MarshalObj.Free;
  end;
end;

class function TToolsJson.ObjectFromJson(aJson: string): TObject;
var
  UnMarshalObj: TJSONUnMarshal;
  JSONObject: TJSONObject;
begin
  Result := nil;
  UnMarshalObj := TJSONUnMarshal.Create;
  try
    // Todo: Json String welcher mit JsomFromObject erstellt wurde, wird nicht in JsonObject zurückgewandelt
    JSONObject := TJSONObject.ParseJSONValue(aJson) as TJSONObject;
    try
      if Assigned(JSONObject) then
        Result := UnMarshalObj.Unmarshal(JSONObject);
    finally
      JSONObject.Free;
    end;
  finally
    UnMarshalObj.Free;
  end;
end;

[lxo]

Hmm.. wenn in den Klassen der ObjectList dann wieder ObjectList enthalten sind wäre das ja schon unschön.
Zum Beispiel, wenn wir Firma noch dazu nehmen, also eine Firma die mehrere Personen enthält.

Dann müsste ja die Klassenstruktur so aussehen damit dies wie gewünscht serialisiert wird oder?
TFirmaJSON.TFirmaList.TFirma.TPersonJSON.TPersonLi st.TPerson

Oder gibt es auch eine Möglichkeit eine Klasse abzuleiten von ObjectList<T> wo der Interceptor dran und von der Klasse dann meine ObjectLists zu abzuleiten, damit die Struktur dann so aussieht:
TFirmaList.TFirma.TPersonList.TPerson


https://docs.microsoft.com/de-de/dot...ots=dotnet-6-0
In c# wandelt der JsonSerializer wie ich das verstehe auch die Listen in JSONArrays um so wie das mit deinen Interceptor-Klassen dann auch wird.

Weißt du ob Embarcadero daran arbeitet das vielleicht auch so zu machen?

[lxo]

Zitat:

Zitat von haentschman (Beitrag 1497357)

Moin...:P

ich hätte noch eine Variante für komplexe Objekte mit Listen <Txxx>: :wink:

Aber da wird ja auch OwnsObjects, Listhelper mit in den JSONString geschrieben. Das möchte ich ja genau verhindern.
Ich möchte eine Instanz exportieren in einem allgemeinen JSONFormat damit auch ein anderer mit z.B. c# auch mit der Datei klar kommt.

[Uwe Raabe]

Zitat:

Zitat von lxo (Beitrag 1497360)

Aber da wird ja auch OwnsObjects, Listhelper mit in den JSONString geschrieben. Das möchte ich ja genau verhindern.
Ich möchte eine Instanz exportieren in einem allgemeinen JSONFormat damit auch ein anderer mit z.B. c# auch mit der Datei klar kommt.

Das ist ja auch genau der Hintergrund für die Interceptor-Klassen. Die wandeln nämlich die Listen in JSON-Arrays um und wieder zurück. Im wesentlichen tun TJson.JsonToObject und TJson.ObjectToJsonXXX ja auch nichts anderes als Marshal und CreateObject (Unmarshal gibt es nur in Data.DBXJSONReflect, die beißt sich aber mit REST.JsonReflect) für die jeweils erzeugten Hilfsklassen aufzurufen (halt nur simpler zu benutzen). Kann man ganz gut in deren Implementierung nachschauen.

Zitat:

Zitat von lxo (Beitrag 1497359)

Oder gibt es auch eine Möglichkeit eine Klasse abzuleiten von ObjectList<T> wo der Interceptor dran und von der Klasse dann meine ObjectLists zu abzuleiten, damit die Struktur dann so aussieht:
TFirmaList.TFirma.TPersonList.TPerson

Man könnte einen Interceptor schreiben, der TJson.ObjectToJsonString dazu bringt, aus einer TObjectList<T> ein Json-Array (fängt mit [ anstatt { an) zu machen. Die Rückwandlung des Json, was ja dann ein Json-Array ist, funktioniert aber nicht mit TJson.JsonToObject, da das explizit ein TJsonObject erwartet und kein TJsonArray. Auch Data.DBXJSONReflect ist da ähnlich restriktiv.

Das wäre dann vielleicht mal was für eine Erweiterung der REST.Json.Helpers Unit. :)

[DeddyH]

Ich habe das für mich jetzt so gelöst, dass ich mir eine Basisklasse TJSONSerializable erstellt habe. Diese geht per RTTI ihre eigenen Properties durch und schaut, ob diese ein Attribut JSONFieldName aufweisen, in welchem der Keyname des JSON-Pairs angegeben ist. Zum Serialisieren wird ein TJSONObject erzeugt und die erwähnten JSON-Pairs gemäß der Readable-Properties hinzugefügt. Zum Deserialisieren geht das Ganze dann für die Writable-Properties andersherum. Eine spezialisierte generische TObjectList gibt es auch, die erstellt dann ein JSONArray mit Elementen der serialisierten TJSONSerializable-Instanzen. Leider habe ich diese Klasse für die Firma geschrieben und darf sie daher nicht einfach veröffentlichen, aber in dem Zusammenhang gibt es hier einen Thread von mir: https://www.delphipraxis.net/209157-...-erkennen.html

Da das IMHO unkritisch ist, kann ich aber zumindest Ausschnitte des Interface-Abschnitts zeigen:

Delphi-Quellcode:

uses System.SysUtils, System.JSON, System.Generics.Collections, System.Rtti;

type
  (* Attribut, mit dem gesteuert wird, wie das Feld im JSON-Objekt
    heißt/heißen soll *)
  JSONFieldNameAttribute = class(TCustomAttribute)
  private
    FFieldname: string;
  public
    constructor Create(const AFieldName: string);
    property Fieldname: string read FFieldname;
  end;

  (* Attribut, mit dem angegeben wird, dass der Standardwert des entsprechenden
    Property-Datentyps als NULL ausgegeben werden soll. Betrifft nur die
    Wandlung in JSON, andersherum nicht, da Delphi keine echten Nullables
    kennt. *)
  JSONNullIfDefaultAttribute = class(TCustomAttribute);

  // Forward-Deklarationen für die Klassenfunktion FromJSON
  TJSONSerializable = class;
  TJSONSerializableClass = class of TJSONSerializable;

  (* Die Parent-Klasse für JSON-Serialisierung. Betrachtet werden alle
    Properties, die das JSONFieldName-Attribut (s.o.) haben. Geparst werden
    einfache Datentypen, Arrays, Objekte (falls von TJSONSerializable
    abgeleitet) und Listen, sofern diese generisch sind.
    Heißt: TList<string> wird abgearbeitet, TStringList hingegen nicht.
    Wir leiten von TInterfacedObject ab, damit wir in Ableitungen ggf. noch
    Interfaces anflanschen können und damit automatische Referenzzählung
    haben. *)
  TJSONSerializable = class(TInterfacedObject)
  public
    constructor Create; virtual;
    function ToJSON: TJSONObject; virtual;
    // Parameter:
    // Obj = das zu parsende JSON-Objekt
    // AClass = die zu erzeugende konkrete Klasse (Ableitung von TJSONSerializable)
    // Um das erzeugte Objekt dann auch vollständig nutzen zu können, muss
    // es noch in den konkreten Typ gecastet werden:
    // MyObj := TMyObj.FromJSON(JsonObjekt, TMyObj) as TMyObj;
    class function FromJSON(const Obj: TJSONObject;
      const AClass: TJSONSerializableClass): TJSONSerializable; static;
  end;

  TJSONSerializableObjectList<T: TJSONSerializable> = class(TObjectList<T>)
  public
    function ToJSON: TJSONArray; virtual;
    class function FromJSON(const Obj: TJSONArray): TJSONSerializableObjectList<T>; static;
  end;

Benutzen lässt sich dann beispielsweise so:

Delphi-Quellcode:

type
  TUserDB = class(TJSONSerializable)
  private
    FName: String;
    FWinAuth: Boolean;
    FIsMySQL: Boolean;
    FPort: Word;
    FDatabase: String;
    FPassword: String;
    FUser: String;
    FServer: String;
  public
    [JSONFieldName('Name')]
    property Name: String read FName write FName;
    [JSONFieldName('Server')]
    property Server: String read FServer write FServer;
    [JSONFieldName('IsMySql')]
    property IsMySql: Boolean read FIsMySQL write FIsMySQL;
    [JSONFieldName('User')]
    property User: String read FUser write FUser;
    [JSONFieldName('Database')]
    property Database: String read FDatabase write FDatabase;
    [JSONFieldName('Password')]
    property Password: String read FPassword write FPassword;
    [JSONFieldName('Port')]    
    [JSONNullIfDefault]
    property Port: Word read FPort write FPort;
    [JSONFieldName('WinAuth')]
    property WinAuth: Boolean read FWinAuth write FWinAuth;
  end;

...

UserDB := TUserDB.Create;
...
{TJSONObject}lObj := UserDB.ToJSON;

[Uwe Raabe]

Zitat:

Zitat von lxo (Beitrag 1497359)

Oder gibt es auch eine Möglichkeit eine Klasse abzuleiten von ObjectList<T> wo der Interceptor dran und von der Klasse dann meine ObjectLists zu abzuleiten

Nein, das geht nicht. Man kann an eine (generische) Klasse kein generisches Attribut anhängen.

Zitat:

Zitat von Uwe Raabe (Beitrag 1497363)

Das wäre dann vielleicht mal was für eine Erweiterung der REST.Json.Helpers Unit. :)

Ich habe das mal entsprechend erweitert und vereinfacht. Die neue Version findet man bei GitHub: https://github.com/UweRaabe/REST-JSon-Helpers

Bezogen auf dein Code-Beispiel und erweitert um die direkten Verarbeitung der Listen könnte das nun so aussehen:

Delphi-Quellcode:

type
  TPerson = class
  private
    FName: String;
  public
    property Name: String read FName write FName;
  end;

  JsonObjectListPersonAttribute = class(JsonObjectListAttribute<TPerson>);

type
  [JsonObjectListPerson]
  TPersonListe = class(TObjectList<TPerson>);

type
  { Wrapper }
  TPersonJSON = class
  private
    [JSONOwned(False)]
    FPersonListe: TPersonListe;
  public
    constructor Create;
    destructor Destroy; override;
    property PersonListe: TPersonListe read FPersonListe write FPersonListe;
  end;

...

const
  cNamen: TArray<String> = ['Name1', 'Name2', 'Name3'];
  cPersonListe = '[{"name":"Name1"},{"name":"Name2"},{"name":"Name3"}]';
  cPersonJSON = '{"personListe":[{"name":"Name1"},{"name":"Name2"},{"name":"Name3"}]}';

  function CheckListe(AListe: TPersonListe): Boolean;
  var
    I: Integer;
  begin
    Result := (AListe.Count = Length(cNamen));
    if Result then begin
      for I := 0 to AListe.Count - 1 do
        if AListe[I].Name <> cNamen[I] then
          Exit(False);
    end;
  end;

var
  lPersonJSON: TPersonJSON;
  lPerson: TPerson;
  lJSONString: String;
  lPersonListe: TPersonListe;
begin
  { mit Wrapper }
  lPersonJSON := TPersonJSON.Create;
  try
    for var lName in cNamen do
    begin
      lPerson := TPerson.Create;
      lPerson.Name := lName;
      lPersonJSON.PersonListe.Add(lPerson);
    end;

    lJSONString := TConvert.ToJSONString(lPersonJSON);
    Assert(lJSONString = cPersonJSON);
  finally
    lPersonJSON.Free;
  end;

  lPersonJSON := TConvert.FromJSON<TPersonJSON>(cPersonJSON);
  try
    Assert(CheckListe(lPersonJSON.PersonListe));
  finally
    lPersonJSON.Free;
  end;

  { Liste direkt }
  lPersonListe := TPersonListe.Create;
  try
    for var lName in cNamen do
    begin
      lPerson := TPerson.Create;
      lPerson.Name := lName;
      lPersonListe.Add(lPerson);
    end;

    lJSONString := TConvert.ToJSONString(lPersonListe);
    Assert(lJSONString = cPersonListe);
  finally
    lPersonListe.Free;
  end;

  lPersonListe := TPersonListe.Create;
  try
    lPersonListe.AddRange(TConvert.FromJSONArray<TPerson>(cPersonListe));
    Assert(CheckListe(lPersonListe));
  finally
    lPersonListe.Free;
  end;

end;

[lowmax_5]

Bei

Code:

lJSONString := TConvert.ToJSONString(lPersonJSON);

bekomme ich einen Fehler mit der Meldung 'Assertion fehlgeschlagen....' (Delphi 11)

[Uwe Raabe]

Zitat:

Zitat von lowmax_5 (Beitrag 1497433)

Bei

Code:

lJSONString := TConvert.ToJSONString(lPersonJSON);

bekomme ich einen Fehler mit der Meldung 'Assertion fehlgeschlagen....' (Delphi 11)

Hmm, kommt hier nicht - auch Delphi 11. Kannst du das komplette Projekt posten?

[lowmax_5]

Klar!

[Uwe Raabe]

Zwischen der Deklaration von JsonObjectListPersonAttribute und dessen Verwendung muss mindestens ein type stehen.

Steht auch so in der Readme:

Zitat:

Also there must be at least one type keyword between the declaration and the use of the attribute.

[lowmax_5]

Vielen Dank! Das hatte ich überlesen und habe wieder was dazu gelernt. Das das zweite Type notwendig ist hätte ich auch nicht erwartet.

[mytbo]

Darf es auch etwas anderes sein? Ich bringe mal das Open Source Framework mORMot ins Spiel. mORMot ist von D7 bis Delphi 11 Alexandria verfügbar. Eine ausführliche Hilfe findest du hier: Hilfe. Weitere Informationen findest du hier: Download, Forum. mORMot musst du nicht installierten. Es reicht aus, die entsprechenden Bibliothekspfade einzufügen.

Mit mORMot kannst du die Published Eigenschaften eines Objekts/Objektliste ohne einen eigenen JSON Serializer schreiben und lesen. Das geht auch bei verschachtelten Objekt-Strukturen. Mit ObjArrayToJson() wird z.B. ein Array of TPerson gespeichert. mORMot verarbeitet fast alles.

Delphi-Quellcode:

type
  TPerson = class(TObject)
  private
    FName: String;
  published
    property Name: String
      read FName write FName;
  end;

FPersonListe: TObjectList;

// In eine Datei speichern
ObjectToJsonFile(FPersonListe, 'test.json', [woObjectListWontStoreClassName]);

// Aus einer Datei laden
JsonFileToObject('test.json', FPersonListe, TPerson);

initialization
  Rtti.RegisterClasses([TPerson]);

Bis bald...
Thomas

[venice2]

@mytbo mORMot ist Top habe deine Hilfe diesbezüglich auch nicht vergessen. :thumb:

[lxo]

Zitat:

Zitat von Uwe Raabe (Beitrag 1497419)

Zitat:

Zitat von lxo (Beitrag 1497359)

Oder gibt es auch eine Möglichkeit eine Klasse abzuleiten von ObjectList<T> wo der Interceptor dran und von der Klasse dann meine ObjectLists zu abzuleiten

Nein, das geht nicht. Man kann an eine (generische) Klasse kein generisches Attribut anhängen.

Zitat:

Zitat von Uwe Raabe (Beitrag 1497363)

Das wäre dann vielleicht mal was für eine Erweiterung der REST.Json.Helpers Unit. :)

Ich habe das mal entsprechend erweitert und vereinfacht. Die neue Version findet man bei GitHub: https://github.com/UweRaabe/REST-JSon-Helpers

Sieht schonmal ganz gut aus die Lösung. Danke Uwe :)
Trotzdem habe ich dabei aber immer noch ein Problem wenn ein Object meiner ObjectList auch eine ObjectList hat.
Da krieg ich beim TConvert.FromJSON eine Zugriffsverletzung.

Zum Beispiel, wenn wir Firma noch dazu nehmen, also eine Firma die mehrere Personen enthält.
TFirmaList.TFirma.TPersonList.TPerson

[Uwe Raabe]

Funktioniert doch tadellos.

Delphi-Quellcode:

type
  TPerson = class
  private
    FName: String;
  public
    property Name: String read FName write FName;
  end;

  JsonObjectListPersonAttribute = class(JsonObjectListAttribute<TPerson>);

type
  [JsonObjectListPerson]
  TPersonList = class(TObjectList<TPerson>)
  end;

type
  TFirma = class
  private
    FName: string;
    [JSONOwned(False)]
    FPersonList: TPersonList;
  public
    constructor Create;
    destructor Destroy; override;
    property Name: string read FName write FName stored False;
    property PersonList: TPersonList read FPersonList write FPersonList;
  end;

  JsonObjectListFirmaAttribute = class(JsonObjectListAttribute<TFirma>);

type
  [JsonObjectListFirma]
  TFirmaList = class(TObjectList<TFirma>)
  end;

type
  { Wrapper }
  TWrapper = class
  private
    [JSONOwned(False)]
    FList: TFirmaList;
  public
    constructor Create;
    destructor Destroy; override;
    property List: TFirmaList read FList write FList;
  end;

...

procedure Test;
const
  cFirmen: TArray<String> = ['Firma1', 'Firma2', 'Firma3'];
  cNamen: TArray<String> = ['Name1', 'Name2', 'Name3'];
  cPersonList = '[{"name":"Name1"},{"name":"Name2"},{"name":"Name3"}]';
  cFirmaList = '[{"name":"Firma1","personList":' + cPersonList + '},' +
               '{"name":"Firma2","personList":' + cPersonList + '},' +
               '{"name":"Firma3","personList":' + cPersonList + '}]';
  cWrapperJSON = '{"list":' + cFirmaList + '}';

  function CheckList(AListe: TPersonList): Boolean; overload;
  var
    I: Integer;
  begin
    Result := (AListe.Count = Length(cNamen));
    if Result then begin
      for I := 0 to AListe.Count - 1 do
        if AListe[I].Name <> cNamen[I] then
          Exit(False);
    end;
  end;

  function CheckList(AListe: TFirmaList): Boolean; overload;
  var
    I: Integer;
  begin
    Result := (AListe.Count = Length(cFirmen));
    if Result then begin
      for I := 0 to AListe.Count - 1 do begin
        if AListe[I].Name <> cFirmen[I] then
          Exit(False);
        if not CheckList(AListe[I].PersonList) then
          Exit(False);
      end;
    end;
  end;

  procedure FillList(Target: TPersonList); overload;
  begin
    for var lName in cNamen do
    begin
      var lPerson := TPerson.Create;
      lPerson.Name := lName;
      Target.Add(lPerson);
    end;
  end;

  procedure FillList(Target: TFirmaList); overload;
  begin
    for var lName in cFirmen do
    begin
      var lFirma := TFirma.Create;
      lFirma.Name := lName;
      FillList(lFirma.PersonList);
      Target.Add(lFirma);
    end;

  end;

var
  lFirma: TFirma;
  lWrapper: TWrapper;
  lJSONString: String;
  lFirmaList: TFirmaList;
begin
  { mit Wrapper }
  lWrapper := TWrapper.Create;
  try
    FillList(lWrapper.List);
    lJSONString := TConvert.ToJSONString(lWrapper);
    Assert(lJSONString = cWrapperJSON);
  finally
    lWrapper.Free;
  end;

  lWrapper := TConvert.FromJSON<TWrapper>(cWrapperJSON);
  try
    Assert(CheckList(lWrapper.List));
  finally
    lWrapper.Free;
  end;

  { Liste direkt }
  lFirmaList := TFirmaList.Create;
  try
    FillList(lFirmaList);
    lJSONString := TConvert.ToJSONString(lFirmaList);
    Assert(lJSONString = cFirmaList);
  finally
    lFirmaList.Free;
  end;

  lFirmaList := TFirmaList.Create;
  try
    lFirmaList.AddRange(TConvert.FromJSONArray<TFirma>(cFirmaList));
    Assert(CheckList(lFirmaList));
  finally
    lFirmaList.Free;
  end;
end;

[lxo]

Tut mir leid, mein Fehler.
Hatte in TFirma FPersonList nicht erzeugt.

Vielen Dank für die Hilfe :thumb:

[haentschman]

Hi...8-)

welcome...:dp:

but...there is also an english one. :zwinker: https://en.delphipraxis.net

[taveuni]

Ich häng mich mal hier an.
Ich versuche seit geraumer Zeit meine Settings mit Hilfe von Uwe Raabes unit Rest.Json.Helpers in Json zu serialsieren. Viellicht habe ich etwas falsch verstanden.
Im Anhang ist ein abgespecktes Beispiel. Das TConvert.ToJSONString funktioniert. Rückwärts aber weder mit TConvert.FromJSON noch mit der Delphi Funktion TJson.JsonToObject.
Irgendwann erhalte ich eine Zugriffsverletzung in System.Generics.Collections in der procedure TListHelper.InternalSetCount4(Value: Integer);
Projekt ist erstellt mit Delphi 10.4.2

Was mache ich falsch?

[TiGü]

Mit Debug-DCU kompiliert, siehst du schnell, dass es eigentlich in REST.Json.Helpers.TObjectListInterceptor<T>.Object sReverter knallt.

Wenn man sich die Zeile

Delphi-Quellcode:

list := TObjectList<T>(ctx.GetType(Data.ClassType).GetField(Field).GetValue(Data).AsObject);

zum Debuggen etwas aufdröselt, dann erhalten wir so ein Konstrukt:

Delphi-Quellcode:

procedure TObjectListInterceptor<T>.ObjectsReverter(Data: TObject; Field: string; Args: TListOfObjects);
var
  ctx: TRTTIContext;
  list: TObjectList<T>;
  obj: TObject;
  RttiType: TRttiType;
  RttiField: TRttiField;
  RttiValue: TValue;
  ListObj: TObject;
begin
  RttiType := ctx.GetType(Data.ClassType);
  RttiField := RttiType.GetField(Field);
  RttiValue := RttiField.GetValue(Data);
  ListObj := RttiValue.AsObject;
  list := TObjectList<T>(ListObj);

  if list <> nil then
  begin
    list.Clear;
    for obj in Args do
      list.Add(T(obj));
  end;
end;

Dadurch bekommst du zumindest die Information, dass der Cast von TValue.AsObject nach der TObjectList<T> (im konkreten Fall TIOList = TObjectList<TIODevice>) fehlschlägt und nil zurückliefert.
In

Delphi-Quellcode:

TValue.AsObject

sieht man, dass Result = nil ist, weil TValue.GetIsEmpty True zurückgibt.
Das liegt daran, weil FAsObject = nil ist.
Warum und Wieso entzieht sich meinen Verständnis. Beim füllen des TValue per

Delphi-Quellcode:

RttiField.GetValue(Data) und TValue.Make

bleibt die TValue.FValueData leer.

[taveuni]

Zitat:

Zitat von TiGü (Beitrag 1500858)

Dadurch bekommst du zumindest die Information, dass der Cast von TValue.AsObject nach der TObjectList<T> (im konkreten Fall TIOList = TObjectList<TIODevice>) fehlschlägt und nil zurückliefert.

Weiter oben hat UWE Raabe geschrieben bei diesem Fehler soll man die Unit REST.Json.Types includieren. Das habe ich vergessen. Aber das Problem ist damit trotzdem vorhanden.

[Uwe Raabe]

Zitat:

Zitat von taveuni (Beitrag 1500860)

Weiter oben hat UWE Raabe geschrieben bei diesem Fehler soll man die Unit REST.Json.Types includieren. Das habe ich vergessen. Aber das Problem ist damit trotzdem vorhanden.

REST.Json.Types muss in der Unit in der Uses stehen, in der das Attribute JSONOwned verwendet wird. Andernfalls wirft der Compiler auch entsprechende Warnungen aus:

Code:

[dcc32 Warnung] uSettings.pas(33): W1074 Unbekanntes benutzerdefiniertes Attribut
[dcc32 Warnung] uSettings.pas(71): W1074 Unbekanntes benutzerdefiniertes Attribut
[dcc32 Warnung] uSettings.pas(74): W1074 Unbekanntes benutzerdefiniertes Attribut

[taveuni]

Zitat:

Zitat von Uwe Raabe (Beitrag 1500863)

Zitat:

Zitat von taveuni (Beitrag 1500860)

Weiter oben hat UWE Raabe geschrieben bei diesem Fehler soll man die Unit REST.Json.Types includieren. Das habe ich vergessen. Aber das Problem ist damit trotzdem vorhanden.

REST.Json.Types muss in der Unit in der Uses stehen, in der das Attribute JSONOwned verwendet wird. Andernfalls wirft der Compiler auch entsprechende Warnungen aus:

Code:

[dcc32 Warnung] uSettings.pas(33): W1074 Unbekanntes benutzerdefiniertes Attribut
[dcc32 Warnung] uSettings.pas(71): W1074 Unbekanntes benutzerdefiniertes Attribut
[dcc32 Warnung] uSettings.pas(74): W1074 Unbekanntes benutzerdefiniertes Attribut

Ja ich habe dies hier nachgeholt. Trotzdem erhalte ich die Zugriffsverletzung beim deserialsieren (TConvert.FromJSON<TSettings>)?

[Uwe Raabe]

TGate hat keinen parameterloses Constructor Create. Deshalb wird das TObject.Create verwendet (das gibt es immer) und somit ist FCameras nicht initialisiert.

Das intern verwendete TJSONUnmarshal erzeugt die Instanzen mit Hilfe der Funktion ObjectInstance. Dort steht als Bemerkung:

Zitat:

It is assumed the object has a no-parameter Create constructor

[taveuni]

Zitat:

Zitat von Uwe Raabe (Beitrag 1500874)

TGate hat keinen parameterloses Constructor Create. Deshalb wird das TObject.Create verwendet (das gibt es immer) und somit ist FCameras nicht initialisiert.

Wow - Vielen Dank! Da wäre ich wohl nie darauf gekommen.