Améliorer la vitesse de traitement en utilisant des tâches parallèles

**ShaiLeTroll** · 14/12/2022, 10h08

Pourquoi passer par TNetHTTPRequest ?
Continue avec le trio TRESTClient, TRESTRequest et TRESTResponse et rempli un couple "TList<record> + TCriticalSection" commune que je te recommande d'encaspuler dans un TWooData en t'inspirant du TThreadList à l'ancienne.

Et fait un vrai TThread, tu verras que c'est bien plus simple pour partager des objets correctement, le TWooData tu le passes en paramètre du Create, tu conserves la référence et tu l'utilises dans Execute(), les N thread pourront la remplir en même sans rissque.

TList<record> ça peut être un MemTable, on peut imaginer une redefinition de Append qui fait Acquire et Post qui fait le Release, c'est transparent, cependant try finally impératif.

**pprem** · 14/12/2022, 10h12

Si tu coinces sur ça, tu peux aussi reprendre ce que j'avais fait ici :
https://github.com/DeveloppeurPascal...hotos-web-REST

Ca peut largement s'optimiser en terme de ressources car ce n'est pas fait pour de gros volumes (puisque je soumets un thread pour chaque élément de liste à télécharger donc c'est en mode bourrin), mais tu peux t'inspirer de ça et modifier ce qui se trouve dans u_download pour faire des ttask.run() et laisser Delphi gérer le pool de threads au lieu des tthread.createAnonymousThread().

Le principe reste le même : chargement d'une liste => traitement des éléments de la liste avec demande de chargement de chacun + traitement de la page suivante en rappellant la même procédure.

Il n'y a pas besoin de faire dans le compliqué.

Là je gère ça sous forme de fichiers, dans ton cas faut voir ce qui nécessite d'être réellement stocké.

Une autre façon de faire est tout bêtement le cas d'un aspirateur de sites comme https://github.com/DeveloppeurPascal...ur-de-site-web
Après tout les ressources ne sont que des URL qui génèrent l'appel d'autres URL ou du traitement des données reçues.

Et la troisième solution est de faire un template côté site qui fournit sous forme de liste déjà toutes les infos dont tu as besoin pour éviter de télécharger la liste puis les fiches. Mais là, faut pouvoir ajouter un programme ou un nouveau modèle d'export sur le site et ce n'est pas forcément possible.

**SergioMaster** · 14/12/2022, 14h51

Alors ça y est enfin, après avoir fouillé longtemps dans les "arcanes" de TNetHTTPClient

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
var Url : string;
    watch : TStopWatch;
begin
   url:='https://xxxxxxxx/eshop/wp-json/wc/v3/products';
   url:=url+'?consumer_key=ck_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'+
            '&consumer_secret=cs_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx';
Pages:=-1;
Watch:=TStopwatch.Create;
Watch.Start;
NetHTTPRequest1.URL:=url+'&page='+1.ToString+'&per_page=100';
NetHTTPRequest1.Execute();
label2.text:='pages '+pages.tostring;
 
TParallel.For(2,pages,
              procedure (p : int64)
                 var AClient : TNetHTTPClient;
                     response : IHTTPResponse;
              begin
                AClient:=TNetHTTPClient.Create(nil);
                response:=AClient.Get(url+'&per_page=100&page='+p.ToString);
                if response.StatusCode=200 then traiterRest(Response.ContentAsString);
            end);
watch.Stop;
FDmemTable2.First;
label2.text:=FDmemTable2.recordcount.ToString + ' en '+ (watch.ElapsedMilliseconds/1000).toString;

Je descends à 16,500 s

**ShaiLeTroll** · 14/12/2022, 15h55

Tu as protégé traiterRest et FDmemTable2 comment du coup ?
TMonitor, TCriticalSection ?

**ShaiLeTroll** · 14/12/2022, 17h44

Code :

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

AClient:=TNetHTTPClient.Create(nil);

Je note TNetHTTPClient et IHTTPResponse
Si response sera libéré par le compteur de référence, n'oublies pas de libérer AClient

Et éventuellement lancé traiterRest sur la page 1

**SergioMaster** · 15/12/2022, 09h24

Honte sur moi de ne pas avoir pensé à libérer les objets créés. Obnubilé par le temps, je ne me suis pas attaché à la mémoire, sur des projets tests, il m'arrive d'oublier le ReportMemoryLeaksOnShutdown.

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
procedure TForm131.btnHTTPClick(Sender: TObject);
var
  Url: string;
  watch: TStopwatch;
  firstresponse: IHTTPResponse;
  FirstClient: TNetHTTPClient;
  pages: integer;
begin
  if FDMemTable2.Active then
    FDMemTable2.EmptyDataSet
  else
    FDMemTable2.Open;
 
  Url := 'https://xxxxxxxxxxxxx/eshop/wp-json/wc/v3/products';
  Url := Url + '?consumer_key=ck_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx' +
    '&consumer_secret=cs_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx';
  pages := -1;
  watch := TStopwatch.Create;
  watch.Start;
  FirstClient := TNetHTTPClient.Create(nil);
  try
    firstresponse := FirstClient.Get(Url + '&page=1&per_page=100');
    if firstresponse.StatusCode = 200 then
    begin
      if firstresponse.ContainsHeader('X-WP-TotalPages') then
        pages := StrToIntDef(firstresponse.HeaderValue['X-WP-TotalPages'], 1);
      traiterrest(firstresponse.ContentAsString);
    end;
    TParallel.For(2, pages,
      procedure(p: int64)
      var
        AClient: TNetHTTPClient;
        Aresponse: IHTTPResponse;
      begin
        AClient := TNetHTTPClient.Create(nil);
        try
          Aresponse := AClient.Get(Url + '&per_page=100&page=' + p.ToString);
          if Aresponse.StatusCode = 200 then
            traiterrest(Aresponse.ContentAsString);
        finally
          AClient.Free;
        end;
      end);
  finally
    FirstClient.Free;
  end;
  watch.Stop;
  FDMemTable2.First;
  Label2.Text := FDMemTable2.RecordCount.ToString + ' en ' +
    (watch.ElapsedMilliseconds / 1000).ToString;
end;

Je n'ai plus qu'à coller ça dans un TTask pour ne pas figer l'application

éventuellement j'aimerais bien savoir comment fournir les paramètres plutôt que de tout coder "en dur" dans l'adresse,
j'ai tenté sans succès de fournir le paramètre Headers de la fonction TNetHTTPClient.Get(url,nil,headers);

Code :

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

1
2
3
4
5
6
7
8
9
    LHeaders: TArray<TNameValuePair>;
begin
  SetLength(LHeaders, 4);
  LHeaders[0] := TNameValuePair.Create('consumer_key','ck_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx');
  LHeaders[1] := TNameValuePair.Create('consumer_secret','cs_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx');
  LHeaders[2] := TNameValuePair.Create('per_page','100');
  LHeaders[3] := TNameValuePair.Create('page','1');
 
  AhttpClient.Get(url,nil,LHeaders);

j'obtiens une erreur 'Unauthorized' donc ce n'est pas ça !

Et éventuellement lancé TraiterRest sur la page 1

oui, évidemment, quand j'ai fait du copier/coller, c'était après un test (obtention du nombre de pages et TParallel.loop à partir de 1) qui, finalement, augmentait le temps de réponse

.
TraiterRest, mal nommée, c'est plutôt TraiterReponse que j'aurais dû mettre est simple

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
procedure TForm131.traiterrest(const Response: String);
var
  JsonArray: TJSONArray;
  ArrayElement: TJSonValue;
begin
  JsonArray := TJSONObject.ParseJSONValue(Response) as TJSONArray;
  try
    for ArrayElement in JsonArray do
    begin
      FDMemTable2.Append;
      FDMemTable2ID.AsInteger := StrToInt(ArrayElement.GetValue<String>('id'));
      FDMemTable2Name.AsString :=
        copy(ArrayElement.GetValue<String>('name'), 1, 80);
      FDMemTable2SKU.AsString :=
        copy(ArrayElement.GetValue<String>('sku'), 1, 20);
      FDMemTable2.Post;
    end;
  finally
    JsonArray.Free;
  end;
 
end;

**ShaiLeTroll** · 15/12/2022, 10h20

Cela m'étonne que tu n'ais pas de collision dans traiterrest !

TParallel.For lance combien de thread par défaut ?
A priori avec un Stride à 1, autant que de Pages (quoi que je vois un lien avec le nombre de coeur avec un plafond de core x 2 ce qui me semble très pertinent), en augmentant Stride, cela utilise le même thread pour plusieurs itérations donc réduit le nombre de thread mais j'avoue me perdre dans le code de TThreadPool.TQueueWorkerThread qui est derrière le WorkerFor ... c'est délirant de complexité, c'est bien pour de micro-thread comme celui que tu mets en place mais faut pas en abuser car je crois n'avoir jamais vu autant de TMonitor et TEvent dans un code pour gérer les synchronisations (la répartition de charge et la prise en compte de la fin des Task)

Code :

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

1
2
3
4
5
6
7
8
9
10
11
    for ArrayElement in JsonArray do
    begin
      FDMemTable2Lock.Acquire(); // TCriticalSection
      try
        FDMemTable2.Append;
        ...
        FDMemTable2.Post;
      finally
         FDMemTable2Lock.Release();
      end;
    end;

**Andnotor** · 15/12/2022, 11h00

Envoyé par SergioMaster

éventuellement j'aimerais bien savoir comment fournir les paramètres plutôt que de tout coder "en dur" dans l'adresse

Pour les entêtes :

Code :

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

1
2
3
4
var LHeaders :TNetHeaders;
 
LHeaders := [TNetHeader.Create('consumer_key','ck_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'),
             TNetHeader.Create('consumer_secret','cs_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx')];

Mais suivant la sécurité mise en place, username/password doivent être passés dans le body en format json. A voir.

L'accès aux pages se fait par l'URL :

Code :

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

1
2
3
URL := TURI.Create(Host);
URL.AddParameter('page', Page.ToString);
URL.AddParameter('per_page', '100');

**Andnotor** · 15/12/2022, 11h32

A titre d'exemple, je te mets ma propre implémentation d'un client REST WordPress/WooCommerce basée sur TNetHttpClient.
Est incluse l'authentification Bearer basée sur ce plug-in (procédure CheckToken).

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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
unit HttpREST;
 
interface
 
uses
  Windows, Messages, SysUtils, Variants, Classes, Dialogs, Types,
  System.JSON, System.Net.HttpClientComponent, System.Net.URLClient, System.Net.HTTPClient;
 
type
  TokenException = class(Exception);
 
  THTTPREST = class;
 
  THTTPRESTTStatus = (rsSuccess, rsError, rsReceive, rsSend);
  THTTPRESTStatusEvent = procedure(Sender :THTTPREST; aStatus :THTTPRESTTStatus) of object;
 
  THTTPREST = class
  private const
    BearerPath      = 'wp-json/api-bearer-auth/v1/';
    AuthPath        = BearerPath +'login';
    AuthRefreshPath = BearerPath +'tokens/refresh';
    JSonContent     = 'application/json; charset=UTF-8';
    JPegContent     = 'image/jpeg';
 
  private type
    TExecKind = (ekGET, ekPOST, ekPOSTFILE, ekPUT, ekDELETE);
 
    TError = record
      Code    :string;
      Message :string;
      Status  :integer;
      OldID   :integer;
    end;
 
  private
    Host         :string;
    UserName     :string;
    Password     :string;
    AccessToken  :string;
    RefreshToken :string;
    AuthFile     :string;  // Fichier ini avec une section Bearer
    Expire       :TDateTime;
    HttpClient   :TNetHttpClient;
    Response     :TJSONValue;
    HttpResponse :IHttpResponse;
    FError       :TError;
    FOnStatus    :THTTPRESTStatusEvent;
 
    procedure    CheckToken;
    function     MakeHeaders(const aContentType :string = JSonContent; aLength :integer = 0; const aFileName :string = '') :TNetHeaders;
    procedure    MakeResponse(const aResponseText :string);
    procedure    Execute(aExecKind :TExecKind; const aSubLink :string; const aBody :TJSonObject = nil;
                         const aFileName :string = ''; const aContentType: string = JSonContent; aPage :integer = 1; aParams :TURIParameters = []);
    function     GetID: integer;
    function     GetHeader(const aName: string): string;
    procedure    DoStatus(aStatus :THTTPRESTTStatus);
  public
    /// <summary> Erreur après exécution </summary>
    property     Error :TError read FError;
    /// <summary> Header de la réponse </summary>
    property     Header[const AName: string]: string read GetHeader;
    /// <summary> ID trouvé dans la réponse </summary>
    property     ToID :integer read GetID;
    /// <summary> Réponse en format JSon </summary>
    property     ToJSon :TJSONValue read Response;
    property     OnStatus :THTTPRESTStatusEvent read FOnStatus write FOnStatus;
 
    function     Get(const aSubLink :string; aPage :uint = 1; aParams :TURIParameters = []) :TJsonValue;
    function     Post(const aSublink :string; const aBody :TJSonObject = nil; aParams :TURIParameters = []) :integer; overload;
    function     Post(const aSubLink, aFileName :string; const aContentType :string = JPegContent; aParams :TURIParameters = []) :integer; overload;
    function     Put(const aSublink :string; const aBody :TJSonObject; aParams :TURIParameters = []) :integer;
    procedure    Delete(const aSubLink :string);
 
    constructor  Create(const aHost, aUserName, aPassword :string; const aAuthFile :string = '');
    destructor   Destroy; override;
  end;
 
implementation
 
uses IOUtils, IniFiles, DateUtils, StrUtils, Helper.System.IOUtils;
 
{ THTTPRequest }
 
//=====================================================================================================================================================================================================
procedure THTTPREST.CheckToken;
 
  //--------------------------------------------------------------------------------------------------
  function DoCheckToken(const aSublink :string; aBody :TJSonObject) :boolean;
  begin
    var DT := Now;
 
    Execute(ekPOST, aSublink, aBody);
 
    if FError.Status = 0 then
    begin
      if Response.TryGetValue<string>('access_token', AccessToken) then
      begin
        RefreshToken := Response.GetValue<string>('refresh_token', RefreshToken);
        Expire       := Incsecond(DT, Response.GetValue<integer>('expires_in', 0));
 
        if not AuthFile.IsEmpty then
          with TIniFile.Create(AuthFile) do
          try
            WriteString('Bearer', 'AccessToken', AccessToken);
            WriteString('Bearer', 'RefreshToken', RefreshToken);
            WriteDateTime('Bearer', 'Expire', Expire);
          finally
            Free;
          end;
 
        Exit(TRUE);
      end;
    end;
 
    Result := FALSE;
  end;
  //--------------------------------------------------------------------------------------------------
 
begin
  if Expire < Now then
  begin
    var Body := TJSonObject.Create;
 
    try
      if not RefreshToken.IsEmpty then
      begin
        Body.AddPair('token', RefreshToken);
        if DoCheckToken(AuthRefreshPath, Body) then Exit;
 
        Body.RemovePair('token');
      end;
 
      Body.AddPair('username', Username);
      Body.AddPair('password', Password);
 
      if not DoCheckToken(AuthPath, Body) then
        Raise Exception.Create('Invalid Username or Password.');
 
    finally
      Body.Free;
    end;
  end;
end;
 
//=====================================================================================================================================================================================================
constructor THTTPREST.Create(const aHost, aUserName, aPassword :string; const aAuthFile :string);
begin
  inherited Create;
 
  Host     := aHost;
  UserName := aUserName;
  Password := aPassword;
  AuthFile := aAuthFile;
 
  if not AuthFile.IsEmpty then
    with TIniFile.Create(AuthFile) do
    try
      AccessToken  := ReadString('Bearer', 'AccessToken', '');
      RefreshToken := ReadString('Bearer', 'RefreshToken', '');
      Expire       := ReadDateTime('Bearer', 'Expire', 0);
    finally
      Free;
    end;
 
  HttpClient := TNetHttpClient.Create(nil);
end;
 
//=====================================================================================================================================================================================================
destructor THTTPREST.Destroy;
begin
  Response.Free;
  HttpClient.Free;
 
  inherited;
end;
 
//=====================================================================================================================================================================================================
procedure THTTPREST.DoStatus(aStatus: THTTPRESTTStatus);
begin
  if Assigned(FOnStatus) then
    FOnStatus(Self, aStatus);
end;
 
//=====================================================================================================================================================================================================
function THTTPREST.MakeHeaders(const aContentType :string; aLength :integer; const aFileName: string): TNetHeaders;
begin
  Result := [TNetHeader.Create('Authorization', 'Bearer ' +AccessToken),
             TNetHeader.Create('Content-Type', aContentType),
             TNetHeader.Create('Content-Length', aLength.ToString),
             TNetHeader.Create('Connection', 'keep-alive')];
 
  if not aFileName.IsEmpty then
    Result := Result +[TNetHeader.Create('Content-Disposition', 'attachment; filename=' +TPath.GetFileName(aFileName))];
end;
 
//=====================================================================================================================================================================================================
procedure THTTPREST.MakeResponse(const aResponseText: string);
begin
  Response.Free;
  Response := TJSOnObject.ParseJSONValue(aResponseText);
 
  // Réponse différente entre WordPress et WooCommerce
  FError.Code    := Response.GetValue<string>('code', Response.GetValue<string>('error', 'success'));
  FError.Message := Response.GetValue<string>('message', Response.GetValue<string>('error_description', 'succès'));
  FError.Status  := Response.GetValue<integer>('data.status', StrToIntDef(Response.GetValue<string>('code', '0'), 0));
  FError.OldID   := Response.GetValue<integer>('data.resource_id', 0);
 
  if FError.Status <> 0 then
  begin
    DoStatus(rsError);
 
    if SameText(FError.Code, 'api_bearer_auth_not_logged_in') then
    begin
      Expire := 0;
      raise TokenException.Create(FError.Message);
    end
 
    else if SameText(FError.Code, 'api_api_bearer_auth_error_invalid_token') then
    begin
      RefreshToken := '';
      raise TokenException.Create(FError.Message);
    end;
 
    raise Exception.CreateFmt('%d - %s', [FError.Status, FError.Message]);
  end
  else DoStatus(rsSuccess);
end;
 
//=====================================================================================================================================================================================================
procedure THTTPREST.Execute(aExecKind: TExecKind; const aSubLink: string; const aBody: TJSonObject;
  const aFileName: string; const aContentType: string; aPage: integer; aParams :TURIParameters);
const
  Status : array[boolean] of THTTPRESTTStatus = (rsSend, rsReceive);
begin
  DoStatus(Status[aExecKind = ekGet]);
 
  var URL         := TURI.Create(Host +aSubLink);
  URL.Params      := aParams;
  var RespContent := TStringStream.Create;
 
  try
    case aExecKind of
      ekGET      : begin
                     URL.AddParameter('page', aPage.ToString);
                     URL.AddParameter('per_page', '100');
                     HttpResponse := HttpClient.Get(URL.ToString, RespContent, MakeHeaders);
                   end;
 
      ekPOST     : begin
                     var Content := TStringStream.Create(aBody.ToString, TEncoding.UTF8);
                     try
                       HttpResponse := HttpClient.Post(URL.ToString, Content, RespContent, MakeHeaders(JSonContent, Content.Size));
                     finally
                       Content.Free;
                     end;
                   end;
 
      ekPOSTFILE : HttpResponse := HttpClient.Post(URL.ToString, aFileName, RespContent, MakeHeaders(aContentType, TFile.GetSize(aFileName), aFileName));
 
      ekPUT      : begin
                     var Content := TStringStream.Create(aBody.ToString, TEncoding.UTF8);
                     try
                       HttpResponse := HttpClient.Put(URL.ToString, Content, RespContent, MakeHeaders(JSonContent, Content.Size));
                     finally
                       Content.Free;
                     end;
                   end;
 
      ekDELETE   : begin
                     URL.AddParameter('force', 'true');
                     HttpResponse := HttpClient.Delete(URL.ToString, RespContent, MakeHeaders);
                   end;
    end;
 
    MakeResponse(RespContent.DataString);
 
  finally
    RespContent.Free;
  end;
end;
 
//=====================================================================================================================================================================================================
function THTTPREST.GetHeader(const aName: string): string;
begin
  Result := HttpResponse.HeaderValue[aName];
end;
 
//=====================================================================================================================================================================================================
function THTTPREST.GetID: integer;
begin
  Result := Response.GetValue<integer>('id', 0);
end;
 
//=====================================================================================================================================================================================================
function THTTPREST.Get(const aSubLink: string; aPage: uint; aParams :TURIParameters): TJsonValue;
begin
  CheckToken;
  Execute(ekGET, aSubLink, nil, '', '', aPage, aParams);
  Result := Response;
end;
 
//=====================================================================================================================================================================================================
procedure THTTPREST.Delete(const aSubLink: string);
begin
  CheckToken;
  Execute(ekDELETE, aSubLink);
end;
 
//=====================================================================================================================================================================================================
function THTTPREST.Post(const aSubLink, aFileName, aContentType: string; aParams :TURIParameters): integer;
begin
  CheckToken;
  Execute(ekPOSTFILE, aSubLink, nil, aFileName, aContentType, 1, aParams);
  Result := GetID;
end;
 
//=====================================================================================================================================================================================================
function THTTPREST.Post(const aSublink: string; const aBody: TJSonObject; aParams :TURIParameters): integer;
begin
  CheckToken;
  Execute(ekPOST, aSubLink, aBody, '', JSonContent, 1, aParams);
  Result := GetID;
end;
 
//=====================================================================================================================================================================================================
function THTTPREST.Put(const aSublink: string; const aBody: TJSonObject; aParams :TURIParameters): integer;
begin
  CheckToken;
  Execute(ekPUT, aSubLink, aBody, '', JSonContent, 1, aParams);
  Result := GetID;
end;
 
end.

Améliorer la vitesse de traitement en utilisant des tâches parallèles

Langage Delphi

Discussions similaires

Partager

Partager