REST.Json.TJson serialisiert "falsch" leere dyn. Arrays?

[TiGü]

Hallo zusammen,

ich bin gerade über einen Fall gestolpert, wo ein REST-WebService unbedingt leere Arrays als

Code:

{"dataItems":[]}

codiert haben möchte.
Der Serialisierer aus REST.Json.TJson macht mir aber daraus immer

Code:

{"dataItems":null}

.
Soll das so? Erlaubt der JSON-Standard beide Varianten?
Kann ich das beeinflussen? Die optionalen TJsonOptions haben mich nicht weitergebracht.
Gibt es noch eine einfache Möglichkeit außer sich das JSON per Hand zurecht zu friemeln?

Nicht falsch verstehen, ein StringReplace um null mit [] zu ersetzen ist jetzt nicht das Drama, aber ich wundere mich schon.

Delphi ist Berlin 10.2!

Zum drübergucken:

Delphi-Quellcode:

program JSONDeserialisationProblem;

{$APPTYPE CONSOLE}

{$R *.res}

uses
  System.SysUtils,
  REST.Json,
  System.JSON,
  DefinitionUnit in 'DefinitionUnit.pas';

procedure Main;
var
  MyItems: TArrayOfDataItem;
  Response1: IResponse;
  Response2: IResponse;
  I: Integer;
  JsonObject: TJSONObject;
  ObjectAsJSONString,
  ObjectAsJSONString2,
  ObjectAsJSONString3,
  ObjectAsJSONString4: string;
  Count: Integer;
begin
  Response1 := TResponse.Create;
  Count := 0; //Length(MyItems) + 3;

  SetLength(MyItems, Count);
  for I := low(MyItems) to high(MyItems) do
  begin
    MyItems[I] := TDataItem.Create;
    MyItems[I].Data := I;
  end;
  Response1.Items := MyItems;

  JsonObject := TJson.ObjectToJsonObject(Response1 as TResponse);

  ObjectAsJSONString := TJson.Format(JsonObject);
  ObjectAsJSONString2 := JsonObject.ToString;
  ObjectAsJSONString3 := JsonObject.ToJSON;
  ObjectAsJSONString4 := TJson.JsonEncode(JsonObject);

  Writeln(ObjectAsJSONString);
  Writeln(ObjectAsJSONString2);
  Writeln(ObjectAsJSONString3);
  Writeln(ObjectAsJSONString4);

  Response2 := TJson.JsonToObject<TResponse>(ObjectAsJSONString);
end;

begin
  ReportMemoryLeaksOnShutdown := True;
  try
    Main;
    Readln;
  except
    on E: Exception do
      Writeln(E.ClassName, ': ', E.Message);
  end;

end.

Delphi-Quellcode:

unit DefinitionUnit;

interface

type

  IDataItem = interface;
  TArrayOfDataItem = array of IDataItem;

  IDataItem = interface
  ['{C0AB4BD7-3C7B-4E79-949F-5DCEB7A560F9}']
    function GetData: Int64; stdcall;
    procedure SetData(const Value: Int64); stdcall;

    property Data: Int64 read GetData write SetData;
  end;

  TDataItem = class(TInterfacedObject, IDataItem)
  private
    FData: Int64;

    function GetData: Int64; stdcall;
    procedure SetData(const Value: Int64); stdcall;
  public
    property Data: Int64 read GetData write SetData;
  end;

  IResponse = interface
    ['{691AD522-27B9-4F20-95ED-C192D73D6EE2}']
    function GetItems: TArrayOfDataItem; stdcall;
    procedure SetItems(const Value: TArrayOfDataItem); stdcall;
    property Items: TArrayOfDataItem read GetItems write SetItems;
  end;

  TResponse = class(TInterfacedObject, IResponse)
  private
    FDataItems: TArray<TDataItem>; // TArrayOfDataItem;
    function GetItems: TArrayOfDataItem; stdcall;
    procedure SetItems(const Value: TArrayOfDataItem); stdcall;
  public
    property Items: TArrayOfDataItem read GetItems write SetItems;
  end;

implementation

{ TDataItem }

function TDataItem.GetData: Int64;
begin
  Result := FData;
end;

procedure TDataItem.SetData(const Value: Int64);
begin
  FData := Value;
end;

{ TResponse }

function TResponse.GetItems: TArrayOfDataItem;
var
  I: Integer;
begin
  SetLength(Result, Length(FDataItems));
  for I := Low(FDataItems) to High(FDataItems) do
  begin
    Result[I] := FDataItems[I] as IDataItem;
  end;
end;

procedure TResponse.SetItems(const Value: TArrayOfDataItem);
var
  I: Integer;
begin
  SetLength(FDataItems, Length(Value));
  for I := Low(FDataItems) to High(FDataItems) do
  begin
    FDataItems[I] := Value[I] as TDataItem;
  end;
end;


end.

Zum Runterladen:

[Zacherl]

Zitat von TiGü:

Soll das so? Erlaubt der JSON-Standard beide Varianten?

Das obliegt leider nicht dem JSON Standard, sondern der entsprechenden API Beide Varianten sind (syntaktisch gesehen) legitimes JSON. Genauso könnte an der Stelle eine numerische 0 oder ein leerer String etc. stehen, wenn die API das für sinnvoll erachtet.

[Der schöne Günther]

Ich bin nicht durch den Quelltext gegangen, aber ein Synonym für ein leeres Array [] ist tatsächlich nil . Nicht dass hier unbeabsichtigt irgendeine Optimierung greift und der entsprechende Serialisierungsmechanismus tatsächlich einen Nullpointer bekommt...

[TiGü]

Zitat von Der schöne Günther:

Ich bin nicht durch den Quelltext gegangen, aber ein Synonym für ein leeres Array [] ist tatsächlich nil . Nicht dass hier unbeabsichtigt irgendeine Optimierung greift und der entsprechende Serialisierungsmechanismus tatsächlich einen Nullpointer bekommt...

Wenn man in TJson.ProcessOptions reinschaut, dann ist an der folgenden kommentiert-markierten Stelle für mein leeres Array der Typ von LPair.JsonValue nicht TJSONArray sondern TJSONNull.

Delphi-Quellcode:

class procedure TJson.ProcessOptions(AJsonObject: TJSOnObject; AOptions: TJsonOptions);
var
  LPair: TJSONPair;
  LItem: TObject;
  i: Integer;

  function IsEmpty(ASet: TJsonOptions):boolean;
  var
    LElement: TJsonOption;
  begin
    Result := true;
    for LElement in ASet do
    begin
      Result := false;
      break;
    end;
  end;

begin
  if assigned(AJsonObject) and not isEmpty(AOptions) then

   for i := AJsonObject.Count -1 downto 0  do
    begin
      LPair := TJSONPair(AJsonObject.Pairs[i]);
      if LPair.JsonValue is TJSOnObject then
        TJson.ProcessOptions(TJSOnObject(LPair.JsonValue), AOptions)
      else if LPair.JsonValue is TJSONArray then // <------- hier beginnt meine Fahrt zur Hölle! LPair.JsonValue ist für ein leeres dynamisches Array von Typ TJsonNull!
      begin
        if (joIgnoreEmptyArrays in AOptions) and (TJSONArray(LPair.JsonValue).Count = 0) then
        begin
          AJsonObject.RemovePair(LPair.JsonString.Value).DisposeOf;
        end
        else
          for LItem in TJSONArray(LPair.JsonValue) do
          begin
            if LItem is TJSOnObject then
              TJson.ProcessOptions(TJSOnObject(LItem), AOptions)
          end;
      end
      else
      begin
        if (joIgnoreEmptyStrings in AOptions) and (LPair.JsonValue.value = '') then
        begin
          AJsonObject.RemovePair(LPair.JsonString.Value).DisposeOf;
        end;
      end;
    end;
end;

[Zacherl]

Scheint ziemlich schlecht implementiert zu sein. Die joIgnoreEmptyArrays Option macht so natürlich absolut keinen Sinn.

Habe auch mal ein wenig rumgesucht, ob es evtl. noch entsprechende Attribute oder Options gibt, aber an einer bestimmten Stelle wird hardcoded auf TValue.IsEmpty geprüft - was bei einem leeren Array zu true evaluiert - und dann "null" hinzugefügt.

Edit:
Als Workaround wirst du bei diesem speziellen Objekt wohl manuell das entsprechende Pair entfernen (und ggfls. als leeres TJSONArray Element neu hinzufügen) müssen.

[TiGü]

Zitat von Zacherl:

Edit:
Als Workaround wirst du bei diesem speziellen Objekt wohl manuell das entsprechende Pair entfernen (und ggfls. als leeres TJSONArray Element neu hinzufügen) müssen.

Wäre zwar irgendwie "richtiger", aber da der entstehende JSON-String für mein eigentliches Problem-Objekt recht kompakt ist und es sonst nur String- und Zahlen-Typen hat bin ich jetzt auf diese hemdsärmlige Lösung umgestiegen:

Delphi-Quellcode:

 
function FixJsonSerializationForEmptyArrays(const AJsonString: string): string;
begin
  Result := StringReplace(AJsonString, 'null', '[]', [rfReplaceAll, rfIgnoreCase])
end;

[Stevie]

Zitat von Zacherl:

Habe auch mal ein wenig rumgesucht, ob es evtl. noch entsprechende Attribute oder Options gibt, aber an einer bestimmten Stelle wird hardcoded auf TValue.IsEmpty geprüft - was bei einem leeren Array zu true evaluiert - und dann "null" hinzugefügt.

Daran bin ich wohl schuld
https://quality.embarcadero.com/browse/RSP-13747

[TiGü]

Zitat von Stevie:

Zitat von Zacherl:

Habe auch mal ein wenig rumgesucht, ob es evtl. noch entsprechende Attribute oder Options gibt, aber an einer bestimmten Stelle wird hardcoded auf TValue.IsEmpty geprüft - was bei einem leeren Array zu true evaluiert - und dann "null" hinzugefügt.

Daran bin ich wohl schuld
https://quality.embarcadero.com/browse/RSP-13747

Teert und federt ihn!

[Der schöne Günther]

In 10.2 Tokyo ist das angeblich gefixed. Der Report hier ist als korrigiert aufgelistet:

https://quality.embarcadero.com/browse/RSP-14615

[TiGü]

Hm, ist doch aber noch auf:
Status:Open
Resolution: Unresolved