REST.Json.TJson.ObjectToJsonString formatiert ausgeben?

[frankyboy1974]

hallo,

:kiss::balloon:

mfg

[Sir Rufo]

Also das ist dabei seit XE5
http://docwiki.embarcadero.com/Libra...n.TJson.Format
und XE5 wurde im September 2013 veröffentlicht.

Ja, zum Zeitpunkt der Antwort gab es das also schon.

Und um die Verwirrung auf SO in Grenzen zu halten, habe ich das mal als Kommentar an die Antwort gehängt ;)

[Uwe Raabe]

Zitat:

Zitat von Sir Rufo (Beitrag 1313574)

Und um die Verwirrung auf SO in Grenzen zu halten, habe ich das mal als Kommentar an die Antwort gehängt ;)

:thumb:

[TiGü]

Falls jemand wieder vor einen ähnlichen Problem steht:
Ich habe eine noch schönere Lösung (für das Endergebnis) gefunden.
In der JsonWorkbench-Demo aus Delphi 10 Seattle (z.B. C:\Users\Public\Documents\Embarcadero\Studio\17.0\ Samples\Object Pascal\RTL\Json) gibt es Beautifier-Funktion.

Verkürzt sieht das so aus:

Delphi-Quellcode:

unit Format.JSON;

interface

uses
  System.SysUtils,
  System.Classes,
  System.Json.Writers,
  System.Json.Readers,
  System.Json.Types;

type
  TJsonStringWriter = class(TJsonTextWriter)
  private
    FStringBuilder: TStringBuilder;
    FStringWriter: TStringWriter;
  public
    constructor Create;
    destructor Destroy; override;
    function ToString: string; override;
  end;

  TJsonStringReader = class(TJsonTextReader)
  private
    FStringReader: TStringReader;
  public
    constructor Create(const AJson: string);
    destructor Destroy; override;
  end;

  function FormatJsonString(const AJson: string): string;

implementation

function FormatJsonString(const AJson: string): string;
var
  JsonWriter: TJsonStringWriter;
  JsonReader: TJsonStringReader;
begin
  JsonReader := TJsonStringReader.Create(AJson);
  try
    JsonWriter := TJsonStringWriter.Create;
    try
      JsonWriter.Formatting := TJsonFormatting.Indented;
      JsonWriter.WriteToken(JsonReader);
      Result := JsonWriter.ToString;
    finally
      JsonWriter.Free;
    end;
  finally
    JsonReader.Free;
  end;
end;

{ TJsonStringWriter }

constructor TJsonStringWriter.Create;
begin
  FStringBuilder := TStringBuilder.Create;
  FStringWriter := TStringWriter.Create(FStringBuilder);
  inherited Create(FStringWriter);
end;

destructor TJsonStringWriter.Destroy;
begin
  FStringWriter.Free;
  FStringBuilder.Free;
  inherited Destroy;
end;

function TJsonStringWriter.ToString: string;
begin
  Result := FStringBuilder.ToString;
end;

{ TJsonStringReader }

constructor TJsonStringReader.Create(const AJson: string);
begin
  FStringReader := TStringReader.Create(AJson);
  inherited Create(FStringReader);
end;

destructor TJsonStringReader.Destroy;
begin
  FStringReader.Free;
  inherited;
end;

end.

[Sir Rufo]

Ist das nicht ein wenig durch die Brust ins Auge?

Erst in einen JSON-String serialisieren
Dann den String parsen um den
Dann formatiert ausgeben lassen

:gruebel:

[TiGü]

Natürlich wäre es schon besser, wenn man der Funktion REST.Json.TJson.ObjectToJsonString mitgeben könnte, ob man den resultierenden JSONString "minified" oder "beautified" haben möchte.

Ich habe, angespornt durch dein kritische Frage, gerade anderthalb Stunden erfolglos versucht, das Result von TJSON.ObjectToJsonObject (ein TJSONObject = class sealed(TJSONValue)) sinnvoll zu einen formattierten JSON-String auszugeben.
Aber es will es mir nicht gelingen.
Vielleicht morgen mehr.

[TiGü]

Also ich habe einen möglichen Ansatz, aber an einer Stelle brauche ich die Länge für ein Byte-Array und mache hier wieder ein ToString.
Da muss ich noch nach Alternativen suchen.

Delphi-Quellcode:

unit Format.JSON;

interface

uses
  System.SysUtils,
  System.Classes,
  System.JSON,
  System.JSON.Writers,
  System.JSON.Readers,
  System.JSON.Types;

type
  TJsonStringWriter = class(TJsonTextWriter)
  private
    FStringBuilder: TStringBuilder;
    FStringWriter: TStringWriter;
  public
    constructor Create;
    destructor Destroy; override;
    function ToString: string; override;
  end;

  TJsonStreamReader = class(TJsonTextReader)
  private
    FStreamReader: TStreamReader;
  public
    constructor Create(const AJsonObject: TJSONObject);
    destructor Destroy; override;
  end;

function JsonObjectToFormattedString(const AJsonObject: TJSONObject): string;

implementation

function JsonObjectToFormattedString(const AJsonObject: TJSONObject): string;
var
  JsonWriter: TJsonStringWriter;
  JsonReader : TJsonStreamReader;
begin
  JsonReader := TJsonStreamReader.Create(AJsonObject);
  try
    JsonWriter := TJsonStringWriter.Create;
    try
      JsonWriter.Formatting := TJsonFormatting.Indented;
      JsonWriter.WriteToken(JsonReader);
      Result := JsonWriter.ToString;
    finally
      JsonWriter.Free;
    end;
  finally
    JsonReader.Free;
  end;
end;

{ TJsonStringWriter }

constructor TJsonStringWriter.Create;
begin
  FStringBuilder := TStringBuilder.Create;
  FStringWriter := TStringWriter.Create(FStringBuilder);
  inherited Create(FStringWriter);
end;

destructor TJsonStringWriter.Destroy;
begin
  inherited Destroy;
  FStringWriter.Free;
  FStringBuilder.Free;
end;

function TJsonStringWriter.ToString: string;
begin
  Result := FStringBuilder.ToString;
end;

{ TJsonStreamReader }

constructor TJsonStreamReader.Create(const AJsonObject: TJSONObject);
var
  LBytes : TBytes;
  LStream : TStream;
  Len : Integer;
begin
  Len := AJsonObject.ToString.Length * 6; // <--- das ist dann natürlich Quatsch, vielleicht kann man die benötigte Länge auch anderes bestimmen.
  SetLength(LBytes, Len);
  Len := AJsonObject.ToBytes(LBytes, 0);
  SetLength(LBytes, Len);
  LStream := TMemoryStream.Create;
  LStream.WriteBuffer(LBytes, Length(LBytes));
  Assert(LStream.Size <> 0);

  LStream.Position := 0;
  FStreamReader := TStreamReader.Create(LStream);
  inherited Create(FStreamReader);
end;

destructor TJsonStreamReader.Destroy;
begin
  inherited;
  FStreamReader.Free;
end;

end.