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)))