c# client java server nio2
Rebonjour.
Je me suis aperçu avec horreur que mon serveur java en asynchrone (nio2, j'ai pas testé le nio) ne communiquait pas totalement bien avec mon client en c# après avoir vraiment énormément galéré pour comprendre d'ou ça pouvait venir, j'ai a peu près isolé.
M'étant appuyé sur ce que propose MS sur le site internet et qui avait l'air pas mal, j'ai repris ça pour la réception des données.
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
|
private void ReceiveCallback(IAsyncResult ar)
{
try
{
// Retrieve the state object and the client socket
// from the asynchronous state object.
StateObject state = (StateObject)ar.AsyncState;
Socket client = state.workSocket;
// Read data from the remote device.
int bytesRead = client.EndReceive(ar);
Console.WriteLine(bytesRead);
/*
if (bytesRead > 0)
{
// There might be more data, so store the data received so far.
state.sb.Append(Encoding.ASCII.GetString(state.buffer, 0, bytesRead));
// Get the rest of the data.
client.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,
new AsyncCallback(ReceiveCallback), state);
}
else
{
// All the data has arrived; put it in response.
if (state.sb.Length > 1)
{
_reponse = state.sb.ToString();
}
// Signal that all bytes have been received.
receiveDone.Set();
} |
Le client communique bien vers le serveur mais c'est au retour que survient le soucis. De ce que j'ai compris la méthode beginreceive démarre en fait la réception, chaque appel à Endreceive clos... et donc on choppe au milieu vraisemblablement... Hic, Quand le serveur java a fini de transmettre, lui n'envoie plus rien. Ce qui amène en fait que l'on ne passe jamais dans la partie ou "bytesRead <=0". Donc aussi long que soit le texte, on reste toujours bloqué même si la chaine est bien construite.
Alors je crois avoir trouvé une solutino de contournement mais j'ai la tête en vrac ... ça a l'air de fonctionner, si quelqu'un a une meilleure solution je suis preneur, peut êtren epas passer par beginreceive ? Mais ça serait toujours asynchrone ?
Et surtout est ce que tous les cas de figure sont couverts avec l'alternative ou vais je me prendre un mur à un moment ? Ce qui m'inquiète c'est le moment ou une chaine fera pile poil 1024.
Ce que je ne comprends pas ... il y a peu j'ai travaillé avec des entêtes de trame, il me semble bien que tout envoie indique la longueur... donc en soustrayant la longueur de l'entête on sait d'avance la longueur de la trame... quoique non au final c'est peut être pas une bonne idée. je ne sais plus... Est ce qu'on insère un caractère qui dit qu'on continue l'envoie, d'ordinaire ??? j'ai peut être loupé ça... du coté des algos de java on se contente de lire le buffer jusqu'à la fin en fait.
Bref ma solution pour le moment, mais je la sens boiteuse.
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
|
if (bytesRead >= state.buffer.Length)
{
// There might be more data, so store the data received so far.
state.sb.Append(Encoding.ASCII.GetString(state.buffer, 0, bytesRead));
// Get the rest of the data.
client.BeginReceive( state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReceiveCallback), state);
}
else if ( bytesRead < state.buffer.Length )
{
state.sb.Append(Encoding.ASCII.GetString(state.buffer, 0, bytesRead));
_reponse = state.sb.ToString();
receiveDone.Set();
}
else if (bytesRead <=0)
{
// All the data has arrived; put it in res
if (state.sb.Length > 1)
{
_reponse = state.sb.ToString();
}
// Signal that all bytes have been received.
receiveDone.Set();
} |
Merci d'avance.
