[Indy TCPClient] Recupérer le données reçues

bonjour,

J'ai un client IdTCPClient qui se connecte à un serveur, j'arrive à envoyer des données au serveur mais je n'arrive pas à récupérer sa réponse ??? (qui passe bien sur le réseau)

Il n'y a pas d'evenement "OnReceive" et les évenements OnBeginWork, OnWorkEnd... ne se déclenche pas.

Pourriez vous m'aider :wink:
Je ne vois pas comment faire surtout que les fonctions ReadLn, Capture amènenent a un freeze de l'appli.
Merci.

Je viens tout juste d'en parler sur le post http://www.developpez.net/forums/viewtopic.php?t=95926 précédent !

Il faut donc utiliser un thread qui pilote le composant Indy afin d'avoir un comportement non bloquant.
Pour savoir si des données sont disponibles pour le Client, il faut faire du polling sur la fonction Readable() du socket... c'est en tout cas le seul moyen que j'ai trouvé.

J'ai réalisé une classe sur ce principe qui est un wrapper du idTCPClient et qui "crée" un événement OnDataAvailable sur ce principe. Voilà le code tout fait :

Code:

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
unit UIdTCPClientEx;
 
interface
 
uses
  Classes, SysUtils, IdTCPClient, IdComponent;
 
type
  TIdTCPClientThreadEx = class (TThread)
  private
    mOnDataAvailable: TNotifyEvent;
    mTCPClient: TIdTCPClient;
  protected
    procedure DataAvailable;
    procedure Execute; override;
  public
    constructor Create(TCPClient: TIdTCPClient);
  published
    property OnDataAvailable: TNotifyEvent read mOnDataAvailable write 
            mOnDataAvailable;
  end;
 
  TIdTCPClientEx = class (TComponent)
  private
    mCheckForData: Boolean;
    mOnConnected: TNotifyEvent;
    mOnDataAvailable: TNotifyEvent;
    mOnDisconnected: TNotifyEvent;
    mOnStatus: TIdStatusEvent;
    mTCPClient: TIdTCPClient;
    mThread: TIdTCPClientThreadEx;
    procedure DataAvailable(Sender: TObject);
    function GetBoundIP: AnsiString;
    function GetHost: AnsiString;
    function GetPort: Integer;
    function GetReadTimeOut: Integer;
    procedure SetBoundIP(Value: AnsiString);
    procedure SetCheckForData(const Value: Boolean);
    procedure SetHost(Value: AnsiString);
    procedure SetOnConnected(Value: TNotifyEvent);
    procedure SetOnDisconnected(Value: TNotifyEvent);
    procedure SetOnStatus(Value: TIdStatusEvent);
    procedure SetPort(Value: Integer);
    procedure SetReadTimeOut(Value: Integer);
  public
    constructor Create(aOwner: TComponent); override;
    destructor Destroy; override;
    procedure Connect(const ATimeout: Integer = -1);
    procedure Disconnect;
    function ReadLn(ATerminator: string = #10; const ATimeout: Integer = -1; 
            AMaxLineLength: Integer = -1): AnsiString;
    procedure WriteLn(const AOut: string = '');
    property BoundIP: AnsiString read GetBoundIP write SetBoundIP;
    property CheckForData: Boolean read mCheckForData write SetCheckForData;
    property Host: AnsiString read GetHost write SetHost;
    property Port: Integer read GetPort write SetPort;
    property ReadTimeOut: Integer read GetReadTimeOut write SetReadTimeOut;
  published
    property OnConnected: TNotifyEvent read mOnConnected write SetOnConnected;
    property OnDataAvailable: TNotifyEvent read mOnDataAvailable write 
            mOnDataAvailable;
    property OnDisconnected: TNotifyEvent read mOnDisconnected write 
            SetOnDisconnected;
    property OnStatus: TIdStatusEvent read mOnStatus write SetOnStatus;
  end;
 
implementation
 
{ IdTCPClientEx }
 
{
***************************** TIdTCPClientThreadEx *****************************
}
constructor TIdTCPClientThreadEx.Create(TCPClient: TIdTCPClient);
begin
  inherited Create(true);
  mTCPClient := TCPClient;
end;
 
procedure TIdTCPClientThreadEx.DataAvailable;
begin
  if Assigned(mOnDataAvailable) then mOnDataAvailable(Self);
end;
 
procedure TIdTCPClientThreadEx.Execute;
begin
  while not Terminated do
  begin
    try
    if mTCPClient.Connected then
      begin
        if mTCPClient.Socket.Readable(0)
        then DataAvailable
        else sleep(10);
      end;
    except
 
    end;
  end;
end;
 
{ IdTCPClientEx }
 
{
******************************** TIdTCPClientEx ********************************
}
constructor TIdTCPClientEx.Create(aOwner: TComponent);
begin
  inherited Create(aOwner);
  mCheckForData := false;
 
  mTCPClient := TIdTCPClient.Create(aOwner);
  mThread := TIdTCPClientThreadEx.Create(mTCPClient);
  mThread.FreeOnTerminate := true;
  mThread.OnDataAvailable := self.DataAvailable;
end;
 
destructor TIdTCPClientEx.Destroy;
begin
  mThread.Terminate;
  //mTCPClient.Destroy; //destroyed by the Owner component !!
  inherited Destroy;
end;
 
procedure TIdTCPClientEx.Connect(const ATimeout: Integer = -1);
begin
  mTCPClient.Connect(ATimeout);
end;
 
procedure TIdTCPClientEx.DataAvailable(Sender: TObject);
begin
  if Assigned(OnDataAvailable) then OnDataAvailable(self);
end;
 
procedure TIdTCPClientEx.Disconnect;
begin
  mTCPClient.Disconnect;
end;
 
function TIdTCPClientEx.GetBoundIP: AnsiString;
begin
  result := mTCPClient.BoundIP;
end;
 
function TIdTCPClientEx.GetHost: AnsiString;
begin
  result := mTCPClient.Host;
end;
 
function TIdTCPClientEx.GetPort: Integer;
begin
  result := mTCPClient.Port;
end;
 
function TIdTCPClientEx.GetReadTimeOut: Integer;
begin
  result := mTCPClient.ReadTimeOut;
end;
 
function TIdTCPClientEx.ReadLn(ATerminator: string = #10; const ATimeout: 
        Integer = -1; AMaxLineLength: Integer = -1): AnsiString;
begin
  result := mTCPClient.ReadLn(ATerminator, ATimeout, AMaxLineLength);
end;
 
procedure TIdTCPClientEx.SetBoundIP(Value: AnsiString);
begin
  mTCPClient.BoundIP := Value;
end;
 
procedure TIdTCPClientEx.SetCheckForData(const Value: Boolean);
begin
  if mCheckForData <> Value then
  begin
    mCheckForData := Value;
    if Value then mThread.Resume else mThread.Suspend;
  end;
end;
 
procedure TIdTCPClientEx.SetHost(Value: AnsiString);
begin
  mTCPClient.Host := Value;
end;
 
procedure TIdTCPClientEx.SetOnConnected(Value: TNotifyEvent);
begin
  mOnConnected := Value;
  mTCPClient.OnConnected := Value;
end;
 
procedure TIdTCPClientEx.SetOnDisconnected(Value: TNotifyEvent);
begin
  mOnDisconnected := Value;
  mTCPClient.OnDisconnected := Value;
end;
 
procedure TIdTCPClientEx.SetOnStatus(Value: TIdStatusEvent);
begin
  mOnStatus := Value;
  mTCPClient.OnStatus := Value;
end;
 
procedure TIdTCPClientEx.SetPort(Value: Integer);
begin
  mTCPClient.Port := Value;
end;
 
procedure TIdTCPClientEx.SetReadTimeOut(Value: Integer);
begin
  mTCPClient.ReadTimeOut := Value;
end;
 
procedure TIdTCPClientEx.WriteLn(const AOut: string = '');
begin
  mTCPClient.WriteLn(AOut);
end;
 
end.

@+

Ce code là est donc valable pour le client.
En relisant ta question, je me rends compte que tu dis que tu n'arrives pas à lire la reponse déjà au niveau du serveur...
Au niveau du serveur c'est un peu plus simple : il existe un événement OnExecute. Cet événement est en fait la procédure Execute() d'un thread, il suffit donc de faire un gestionnaire d'événement et d'y placer un ReadLn. Les données reçues debloqueront alors le ReadLn et pourront être traitées dans le code qui suit...

Merci beaucoup, je pensais qu'il y avait une methode plus simple.
Pour ce qui est du serveur pas de problème c'est la reponse du serveur à mon client que je n'arrive pas à lire (dans mon applivation cliente).
Je vais essayer d'integrer ton code, mais le fait d'utiliser des thread me fait un peu peur car je en maitrise pas....

Merci encore :!:

Si il y en a qui ont d'autres solutions je veux bien voir :arrow:

:(
Comment fait tu pour savoir la taille de la donnée à lire quand il n'y pas de "terminaison" type #10 ou #13 ?
Je pense que c'est par ce que les données que je reçois n'ont pas de terminaisons que les fontions ReadString ou Capture plante... :idea:

REM: je n'ai pas fait le serveur c'est une application sur laquelle je me connecte.

...

Quand j'ai fais un logiciel d'échange de fichier avec Visual Basic
Pour marquer la fin d'un bloque recu , je finissais par un byte 0

OK, mais je maitrise pas les données reçues, car l'application serveur 'qui envoie) est dans une machine proprietaire.
Moi je dois juste essayer de m'interfacer et dialoguer avec cette machine, je ne peux en aucun cas changer la forme des données.

:(

La fonction ReadLn sert justement à récupérer du texte ! Et dans ce cas il est logique d'avoir un caractère de terminaison (typiquement #0, mais on peut rencontrer aussi #10 ou #13 ou des combinaisons de tous ces caractères).

Je pense que dans ton cas tu devrais t'intéresser aux données brutes reçues, grâce à la fonction ReadFromStack j'imagine.
Sinon, il y a d'autres fonctions de réception dans la propriété Socket du composant IdTCPSocket. Au pire je pense qu'il est possible d'utiliser sa fonction Reicv avec le max d'octets possibles à lire (16384 par défaut je crois) : la fonction retournera quoi qu'il arrive au plus ce qu'il y a dans le tampon de réception...

Merci encore pour toutes ces infos. :D

Je vais surement arriver a le débrouiller seul maintenant.

Pour Info:
Beaucoup de gens recherche les vieux composants CLIENTSOCKET et SERVERSOCKET.
Dans delphi 7 dans l'onglet INTERNET il y a deux composants identique qui s'appel TCPCLIENT et TCPSERVEUR, les icones ne sont pas très parlant mais c'est ça...

Bon dev à tous...