Discussion :

[Gouyon]

Bonjour

Il existe dans delphi une fonctionnalité qui permet de créer une unité qui fait la liaison entre le code et un fichier XML. Je l'utilise assez souvent et elle est assez pratique une fois qu'on a compris le fonctionnement.
Dans les dernières versions de delphi, il y a la possibilité de faire la même chose mais avec un fichier JSON. Sauf que j'ai du mal à comprendre comment ça fonctionne.
Petit exemple:
Voici mon fichier JSON

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
{
    "VILLE": {
        "BATIMENTS": [
            {
                "INDX": "1",
                "ROT": "45",
                "X": "10",
                "Y": "20"
            },
            {
                "INDX": "2",
                "ROT": "45",
                "X": "10",
                "Y": "20"
            }
        ],
        "FOND": "1",
        "ROUTE": "10",
        "TEXTURES": [
            1,
            2,
            3,
            4
        ]
    }
}

Et voici mon unité

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
 
unit jsonville;
 
interface
 
uses
  System.Classes, System.JSON.Serializers, System.Generics.Collections, System.JSON.Converters;
 
type
  TBATIMENT = class;
  TJsonVille = class;
 
  TJsonListConverterTBATIMENT = class(TJsonTypedListConverter<TBATIMENT>);
  TJsonListConverterInteger = class(TJsonTypedListConverter<Integer>);
  TJsonListConverterTJsonVille = class(TJsonTypedListConverter<TJsonVille>);
 
  [JsonSerialize(TJsonMemberSerialization.Public)]
  TBATIMENT = class(TPersistent)
  private
    FINDX: Integer;
    FROT: Integer;
    FX: Integer;
    FY: Integer;
  public
    property INDX: Integer read FINDX write FINDX;
    property ROT: Integer read FROT write FROT;
    property X: Integer read FX write FX;
    property Y: Integer read FY write FY;
  end;
 
  [JsonSerialize(TJsonMemberSerialization.Public)]
  TVILLE = class(TPersistent)
  private
    FBATIMENTS: TObjectList<TBATIMENT>;
    FFOND: Integer;
    FROUTE: Integer;
    FTEXTURES: TList<Integer>;
  public
    constructor Create;
    destructor Destroy; override;
    [JsonConverter(TJsonListConverterTBATIMENT)]
    property BATIMENTS: TObjectList<TBATIMENT> read FBATIMENTS;
    property FOND: Integer read FFOND write FFOND;
    property ROUTE: Integer read FROUTE write FROUTE;
    [JsonConverter(TJsonListConverterInteger)]
    property TEXTURES: TList<Integer> read FTEXTURES;
  end;
 
  [JsonSerialize(TJsonMemberSerialization.Public)]
  TJsonVille = class(TPersistent)
  private
    FVILLE: TVILLE;
  public
    constructor Create;
    destructor Destroy; override;
    property VILLE: TVILLE read FVILLE;
  end;
 
  [JsonSerialize(TJsonMemberSerialization.Public)]
  modeleville = class(TPersistent)
  private
    FDataset: TObjectList<TJsonVille>;
  public
    constructor Create;
    destructor Destroy; override;
    [JsonConverter(TJsonListConverterTJsonVille)]
    property Dataset: TObjectList<TJsonVille> read FDataset;
  end;
 
implementation
 
uses
  System.SysUtils;
 
constructor TVILLE.Create;
begin
  inherited Create;
  FBATIMENTS := TObjectList<TBATIMENT>.Create(True);
  FTEXTURES := TList<Integer>.Create;
end;
 
destructor TVILLE.Destroy;
begin
  FreeAndNil(FBATIMENTS);
  FreeAndNil(FTEXTURES);
  inherited Destroy;
end;
 
constructor TJsonVille.Create;
begin
  inherited Create;
  FVILLE := TVILLE.Create;
end;
 
destructor TJsonVille.Destroy;
begin
  FreeAndNil(FVILLE);
  inherited Destroy;
end;
 
constructor modeleville.Create;
begin
  inherited Create;
  FDataset := TObjectList<TJsonVille>.Create(True);
end;
 
destructor modeleville.Destroy;
begin
  FreeAndNil(FDataset);
  inherited Destroy;
end;
 
initialization
 
  RegisterClass(TBATIMENT);
  RegisterClass(TVILLE);
  RegisterClass(TJsonVille);
  RegisterClass(modeleville);
 
end.

Pour l'utiliser j'ai créé ce petit code

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
leJsonVille := TJsonVille.Create;
  leJsonVille.VILLE.Fond := 12;
  leJsonVille.VILLE.Route := 4;

Mais je ne vois pas comment ajouter des éléments TBATIMENT à mon JSON
J'arrive à créer un nouvel élément TBATIMENT comme ça

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
jsonbat:=jsonville.TBATIMENT.Create;
  jsonbat.INDX:=0;
  jsonbat.ROT:=0;
  jsonbat.X:=0;
  jsonbat.Y:=0;

Mais je ne vois aucune fonction pour l'ajouter à la liste "BATIMENTS"

De même il n'y a aucune fonctionnalité pour récupérer le json sous la forme d'une chaine de caractère pour la sauvegarder ensuite

Si quelqu'un a déjà utilisé cet outil je suis preneur de conseils

[popo]

J'ai regardé vite fait, mais comme ça je dirait simplement avec leJsonVille.VILLE.BATIMENTS.Add(jsonbat);.

[MaxiDonkey]

Il faut passer par une opération de sérialisation, comme suit :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
  leJsonVille := TJsonVille.Create;
  leJsonVille.VILLE.Fond := 12;
  leJsonVille.VILLE.Route := 4;
 
  var jsonbat := TBATIMENT.Create;
  jsonbat.INDX := 0;
  jsonbat.ROT := 6;
  jsonbat.X := 25;
  jsonbat.Y := 12;
 
  // Ajouter un bâtiment
  leJsonVille.VILLE.BATIMENTS.Add(jsonbat);
 
  // Opération de sérialisation avec affichage dans un TMemo
  var Serializer := TJsonSerializer.Create;
  try
    Memo1.Lines.Text := Serializer.Serialize<TJsonVille>(leJsonVille);
  finally
    Serializer.Free;
  end;

Et si tu veux une meilleure lisibilité de ton JSON à l'affichage

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
//uses ajouter l'unité System.JSON
 
  var Serializer := TJsonSerializer.Create;
  try
    var S := Serializer.Serialize<TJsonVille>(leJsonVille);
 
    var JSONValue := TJSONObject.ParseJSONValue(S);
      try
        Memo1.Lines.Text := JSONValue.Format();
      finally
        JSONValue.Free;
      end;
 
  finally
    Serializer.Free;
  end;

Résultat

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
{
    "VILLE": {
        "BATIMENTS": [
            {
                "INDX": 0,
                "ROT": 6,
                "X": 25,
                "Y": 12
            }
        ],
        "FOND": 12,
        "ROUTE": 4,
        "TEXTURES": [
        ]
    }
}

[Gouyon]

Il faut passer par une opération de sérialisation, comme suit :

Merci pour l'information. Au final ce n'est pas aussi pratique que la liaison de donnée xml, c'est dommage, mais c'est un début. Espérons que ça sera amélioré dans l'avenir