Discussion :

[FadeOut]

Bonjour, j'ai un probleme avec un application TCP que j'essaie de faire.

Elle envoie un message à un serveur, qui lui retourne des enregistrement de valeurs (séparés par des virgules). Le problème est que je ne peux prévoir la grandeur de ces enregistrement (souvent plus que 1000 enregistrements) donc je ne peux fixer mon buffer, ce qui m'oblige à faire plusieurs lecture.

Voici le code tiré de la classe TcpSocket qui communique avec le serveur TCP

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
privatevoid WaitForData()
{
if (pfnCallBack == null)
pfnCallBack = newAsyncCallback(OnDataReceived);
// now start to listen for any data...
m_asynResult = client.BeginReceive(m_DataBuffer, 0, m_DataBuffer.Length, SocketFlags.None, pfnCallBack, null);
}
publicvoid OnDataReceived(IAsyncResult asyn)
{
//end receive...
int iRx = 0;
iRx = client.EndReceive(asyn);
char[] chars = newchar[iRx + 1];
System.Text.Decoder d = System.Text.Encoding.UTF8.GetDecoder();
int charLen = d.GetChars(m_DataBuffer, 0, iRx, chars, 0);
System.String szData = new System.String(chars);
if (isNewData)
{
isNewData = false;
receivedData = szData;
}
else
{
receivedData = receivedData + szData;
}
WaitForData();
}


// Fonction sendMessage
// -- Sert a envoy‚ un message … l'h“te de la connection client
// -- Re‡oit en parametre un message de type string
// -- Envoie un erreur … la console si il y a un problŠme
publicvoid sendMessage(String message)
{
try
{
message = message + "\r\n";
byte[] byData = System.Text.Encoding.ASCII.GetBytes(message);
isNewData = true;
client.Send(byData);
WaitForData();
}
catch (SocketException se)
{
MessageBox.Show(se.Message);
}
}
publicstring getMessage()
{
string retour;
if (receivedData != "")
{
retour = receivedData;
}
else
{
retour = "ChaŒne vide!";
}
return retour;
}

ce code est appelé par un bouton dans un formulaire extérieur de cette façon :

Code :

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

1
2
3
4
unClient.sendMessage(message);
reponse = unClient.getMessage();

Il semble que la variable réponse soit rempli trop rapidement car la réponse attendu du serveur arrive après son affectation par "getMessage()"

Y aurait-il un mécanisme que je pourrait utilisé pour différé son affectation, ou une technique qui m'échappe, car je suis un peu nouveau dans ce type d'opérations.

Merci
FadeOut

[StormimOn]

Le problème à mon avis, c'est dans ton envoi de message

La méthode WaitForData n'est pas bloquante (elle porte mal son nom donc), car tu effectues un appel asynchrone dans cette méthode. Résultat, ta méthode sendMessage rend la main avant que tu ais reçu toutes les données et c'est pourquoi ton getMessage ne te renvoie pas le résultat attendu.

Il faudrait que tu fournisses un événement pour indiquer la fin de la réception (pour rester dans de l'asynchrone) afin de récupérer les données

[FadeOut]

Serait-il possible de rendre waitfordata bloquante??? Je suis un peu perdu dans ce genre d'opérations... Il semble que celles-ci s'apparentent au Thread.

Si je voulais créer cet évenement?? de quelle façon devrais-je m'y prendre???


Merci

[StormimOn]

Tu peux rendre le tout bloquant oui, il suffit de ne pas utiliser les méthodes asynchrones pour la réception des données. Utilise la méthode Receive qui est bloquante

En gros tu fais un appel à Receive et si tu as reçu des données tu boucles pour de nouveau faire un Receive jusqu'à ce tu ais reçu toutes les données.

[wiztricks]

synchrone ou pas, rien ne devrait empêcher le serveur d'expédier ses données en plusieurs messages et le client devrait pouvoir les lire avec une taille de buffer quelconque.
Cela suppose un minimum de protocole pour convenir de ce que sont les unités d'information échangées.
- W

[FadeOut]

j'ai trouvé cette fonction sur internet, mais encore là, il faut présumé que nous savons le nombre de byte que nous allons recevoir...

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
privatestaticvoid Receive(Socket socket, byte[] buffer, int offset, int size, int timeout)
{
int startTickCount = Environment.TickCount;
int received = 0; // how many bytes is already received
do
{
if (Environment.TickCount > startTickCount + timeout)
thrownewException("Timeout.");
try
{
received += socket.Receive(buffer, offset + received, size - received, SocketFlags.None);
}
catch (SocketException ex)
{
if (ex.SocketErrorCode == SocketError.WouldBlock ||
ex.SocketErrorCode == SocketError.IOPending ||
ex.SocketErrorCode == SocketError.NoBufferSpaceAvailable)
{
// socket buffer is probably empty, wait and try again
Thread.Sleep(30);
}
else
throw ex; // any serious error occurr
}
} while (received < size);
}

je cherche une façon de pouvoir contourner ce problème....