Bonjour à tous,

J'ai quelques questions le fonctionnement des Sockets en C#, notemment en mode Asynchrone. Ces même Sockets devant faire transiter des objets sérialisé...

Mon application fonctionne sur un mode n Clients se connectant à un Serveur.
Les clients envoient des commandes aux serveurs (sous forme d'objet sérialisé). Le serveurs se chargent de traiter les commandes, et si besoin re dispatch à n Clients des commandes.

Concrètement, on peu imaginer une chat: Client1 envoi un message au serveur, le serveur le renvoi à tous les Clients. Client1 envoi un message privé, le serveur renvoi au destinataire. Client1 change de pseudo, le serveur effectue le changement, et envoi une commande de mise à jour à tous les autres clients.

Actuellement, cela fonctionne presque...
J'ai énormément de mal à faire fonctionner correctement mes Sockets. Les commande sont sérialisé en Byte[], en envoyé de façon classique:
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
_socket.BeginSend(buffer, 0, buffer.Length, SocketFlags.None, OnSend, null);//Envoie asynchrone
[...]
_socket.EndSend(result);//Envoie terminé
La réception est semblable:
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
_socket.BeginReceive(_buffer, 0, _buffer.Length, SocketFlags.None, OnReceive, null);//En attente de réception
[...]
int read = _socket.EndReceive(result);//données reçues
Le premier problème est sur la taille des commandes envoyées...
Si mon Byte[] _buffer est de 256 bytes, mais que j'envoi une commande de 512, la réception se fait en "morceaux", voila ma méthode:
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
int read = _socket.EndReceive(result);
 
_logger.DebugFormat("\t{0} bytes receive.", read);
 
if (_socket.Available > 0)
{
	_logger.DebugFormat("\t{0} bytes still available.", _socket.Available);
	//Il reste de données à lire
 
	//Lecture des données restantes
	Byte[] readBuffer = new Byte[_socket.Available];
	_socket.Receive(readBuffer, 0, readBuffer.Length, SocketFlags.None);
 
	//Ajout des données supplémentaire au données déjà lues.
	Array.Resize(ref _buffer, read + readBuffer.Length);
	readBuffer.CopyTo(_buffer, read);
}
Cela fonctionne très bien. Il arrive cependant que plusieurs commandes soit envoyées sur Socket et de façon très rapproché dans le temps, et ma méthode de lecture provoque la concaténation de deux commandes dans mon Byte[] _buffer...
Et à la dé-sérialisation, seul la première commande est interprété...

Et là je suis complètement perdu... Je ne sais pas absolument pas comment limiter la lecture d'une commande a la fois, ces commandes étant totalement variable en taille (de 256 bytes, à 2048 pour le moment, mais elle vont évoluer encore...)

Si quelqu'un à une quelconque idée, ou simple piste je suis preneur !

Merci de votre aide (et désolé pour le pavé... -_-').