JSONPair mit Extended oder Integer

[Captnemo]

Hi,

ich möchte mir einen JSONString zusammen stellen. Dazu verwende ich DBXJSON.
Mit

Delphi-Quellcode:

JSON.AddPair(TJSONPair.Create('Name','Dieter'));

geht das mit Strings super.
Nur wie kann ich andere Datentypen wie Extended, Integer, Bool usw. hinzufügen?

Umwandeln in einen String scheidet aus, da diese sonst in Quotes gesetzt werden, und dieses von der Gegenstelle dann als String und nicht als Integer oder Float interpretiert wird.

[Sir Rufo]

Mit

Delphi-Quellcode:

JSON.AddPair(TJSONPair.Create('Name', TJSONNumber.Create( 42 ) ));

[Captnemo]

Danke. Damit kann ich schon mal Integerwerte übernehmen.

Für Boolean nehme ich dann JSONTrue bzw. JSONFalse.
Aber wir macht man es bei Extended?

[Sir Rufo]

Mit

Delphi-Quellcode:

JSON.AddPair(TJSONPair.Create('Name', TJSONNumber.Create( 42.0 ) ));

:roll:

[himitsu]

http://docwiki.embarcadero.com/Libra...NNumber.Create :stupid:

Diese Implementation ist halt nicht so schön delphitypisch ausgelegt und um damit manuell JSON zu erstellen ... da hat auch keiner dran gedacht (wie immer)

[Captnemo]

Das merke ich ;)

In der Hilfe in das Create zu schauen, auf die Idee bin ich natürlich nicht gekommen ;) Sorry dafür.

Habt ihr noch einen guten Tipp für Boolean?
Oder muss ich es tatsächlich so machen:

Delphi-Quellcode:

if value then 
  JSON.AddPair(TJSONPair.Create('Tuer',TJSONTrue.Create)) else
  JSON.AddPair(TJSONPair.Create('Tuer',TJSONFalse.Create));

[Sir Rufo]

Also mit ein bisserl gutem Willen und Spucke (class helper) bekommt man folgendes hin:

Delphi-Quellcode:

procedure Test1;
var
  lJson: TJsonObject;
begin
  lJson := TJsonObject.Create;
  lJson.AddPair( TJsonPair.Create( 'int', 42 ) );
  lJson.AddPair( 'double', 42.01 );
  lJson.AddPair( 'bool-a', false );
  lJson.AddPair( 'bool-b', true );

  lJson['foo'] := 'bar';

  WriteLn(lJson.ToJSON);
end;

Code:

{"int":42,"double":42.01,"bool-a":false,"bool-b":true,"str":"str","foo":"bar"}

der Class Helper dazu sieht dann so aus:

Delphi-Quellcode:

type
  TJsonValueRecord = record
  private
    FBuilder: TFunc<TJsonValue>;
  public
    class operator implicit( const i: Integer ): TJsonValueRecord;
    class operator implicit( const i: Int64 ): TJsonValueRecord;
    class operator implicit( const d: double ): TJsonValueRecord;
    class operator implicit( const b: Boolean ): TJsonValueRecord;
    class operator implicit( const s: string ): TJsonValueRecord;
    function BuildJsonValue: TJsonValue;
  end;

  HelperForJsonPair = class helper for TJsonPair
    constructor Create( const Str: string; const Value: TJsonValueRecord ); overload;
  end;

  HelperForJsonObject = class helper for TJsonObject
  private
    procedure SetValue( const AName:string; const Value:TJsonValueRecord );
  public
    procedure AddPair( const Str: string; const Value: TJsonValueRecord ); overload;
    property Values[const AName:string] : TJsonValueRecord write SetValue; default;
  end;

implementation

{ HelperForJsonPair }

constructor HelperForJsonPair.Create( const Str: string; const Value: TJsonValueRecord );
begin
  Create( Str, Value.BuildJsonValue );
end;

{ TJsonValueRecord }

function TJsonValueRecord.BuildJsonValue: TJsonValue;
begin
  Result := FBuilder( );
end;

class operator TJsonValueRecord.implicit( const i: Integer ): TJsonValueRecord;
begin
  Result.FBuilder :=
    function( ): TJsonValue
    begin
      Result := TJSONNumber.Create( i );
    end;
end;

class operator TJsonValueRecord.implicit( const i: Int64 ): TJsonValueRecord;
begin
  Result.FBuilder :=
    function( ): TJsonValue
    begin
      Result := TJSONNumber.Create( i );
    end;
end;

class operator TJsonValueRecord.implicit( const d: double ): TJsonValueRecord;
begin
  Result.FBuilder :=
    function( ): TJsonValue
    begin
      Result := TJSONNumber.Create( d );
    end;
end;

class operator TJsonValueRecord.implicit( const b: Boolean ): TJsonValueRecord;
begin
  Result.FBuilder :=
    function( ): TJsonValue
    begin
      if b
      then
        Result := TJSONTrue.Create
      else
        Result := TJsonFalse.Create;
    end;
end;

class operator TJsonValueRecord.implicit(const s: string): TJsonValueRecord;
begin
  Result.FBuilder :=
    function( ): TJsonValue
    begin
      Result := TJSONString.Create( s );
    end;
end;

{ HelperForJsonObject }

procedure HelperForJsonObject.AddPair( const Str: string;
  const Value: TJsonValueRecord );
begin
  AddPair( TJsonPair.Create( Str, Value ) );
end;

procedure HelperForJsonObject.SetValue(const AName: string;
  const Value: TJsonValueRecord);
begin
  AddPair( AName, Value );
end;

P.S. Ja, ich bin auch der Meinung, die JSON-Bibliothek hätte das so oder anders gleich schon von Haus aus mitbringen sollen :)

[Captnemo]

Super, dass spart mir natürlich eine Masse an Arbeit ;) Das muss ich mir erst mal auf der Zunge zergehen lassen.
Sag mal hast du über die Jahre so einen großen Helperclass-Fundus, oder zimmerst du so was aus dem Hut mal eben in Plaintext runter? Hut ab.

Diese Helperklasse beantwortet natürlich auch gleich meine letzte Frage. Danke.

[Sir Rufo]

Nun ja, das ist eigentlich Schema F.

Einen Record wegen dem impliziten Cast
Ein Closure als Factory
Ein/Zwei Class Helper um die Funktionalität unterzujubeln

Mehr ist es ja nicht :stupid:

[Uwe Raabe]

Zitat:

Zitat von Captnemo (Beitrag 1327362)

Habt ihr noch einen guten Tipp für Boolean?

Ab Seattle geht immerhin:

Delphi-Quellcode:

JSON.AddPair(TJSONPair.Create('Tuer',TJSONBool.Create(value)))

[Sir Rufo]

Zitat:

Zitat von Uwe Raabe (Beitrag 1327367)

Zitat:

Zitat von Captnemo (Beitrag 1327362)

Habt ihr noch einen guten Tipp für Boolean?

Ab Seattle geht immerhin:

Delphi-Quellcode:

JSON.AddPair(TJSONPair.Create('Tuer',TJSONBool.Create(value)))

Was auch nicht wirklich angenehm ist.

Da ist mir

Delphi-Quellcode:

JSON.AddPair( 'Tuer', value);

wesentlich lieber, schon wegen der Übersichtlichkeit (und der wesentlich geringeren Tipparbeit) ;)

Und noch schicker wäre es mit

Delphi-Quellcode:

JSON['Tuer'] := value;

:mrgreen:

P.S. Hab die Erweiterung dafür mal oben ergänzt ;)

[Captnemo]

Zitat:

Zitat von Sir Rufo (Beitrag 1327366)

Nun ja, das ist eigentlich Schema F.

Einen Record wegen dem impliziten Cast
Ein Closure als Factory
Ein/Zwei Class Helper um die Funktionalität unterzujubeln

Mehr ist es ja nicht :stupid:

Ja, Nee, is klar ;) Wenn mir das mal so locker von der Hand gehen würde, dann würde ich gleich mal meinen Nickname ändern ;)

Zitat:

Zitat von Sir Rufo (Beitrag 1327368)

Und noch schicker wäre es mit

Delphi-Quellcode:

JSON['Tuer'] := value;

:mrgreen:

So hätte ich mir das gewünscht. Wenn ich da mal ein kurzen Blick auf Python werfe (nur mal auf dieses Thema bezogen)....naja.

Jetzt muss ich das ganze nur noch als Array verpacken. Mal sehen wie weit ich komme ;) (Die Hilfe hat mir bei JSON bisher nur wenig genützt)

[Sir Rufo]

Hier habe ich so etwas auch schon mal verwurstet

https://github.com/SirRufo/PropertyList

[Captnemo]

Das mit dem TJSONArray hab ich hinbekommen.
Aber wie füge ich dieses jetzt dem JSONObject hinzu?

Wenn ich das so mache

Delphi-Quellcode:

JSON.AddPair('TestArray',JSONArray.ToString);

dann habe ich das Array mit Quotes, was im Grund ja falsch ist.
Ich müsste es ja ohne Quotes hinzufügen.

[Captnemo]

Hat sich erledigt ;) Einfach mal das ToString weglassen.

Man, das ist ein Gewurschtel. Wahrscheinlich alles Gewöhnungssache.