Bonjour,

Je suis en train de coder une librairie de client/serveur pour un protocole assimilé à telnet. En gros, l'utilisateur se connecte avec telnet au serveur, il saisis des commandes au clavier, le serveur lui renvoie une réponse.
Concrètement :
 - le serveur c'est un TcpListener qui génère des TcpClient, on récupère le flux (GetStream), on y met un streamreader et un streamwriter.
 - côté client, un TcpClient qui se connecte, un StreamReader et un StreamWriter sur le flux.

Là où ça pose problème, c'est pour activer un mode compressé, qui n'est autre q'une compression GZip du flux réseau.
En gros, avant :

Serveur [StreamReader/StreamWriter] =<=>= [NetworkStream] =<=>= ... Internet ... =<=>= [NetworkStream] =<=>= [StreamReader/StreamWriter] Client

Après
Serveur [StreamWriter] =>= [GZipStream(compress)] =>= [NetworkStream] =<=>= ... Internet ...
             [StreamReader] =<= [GZipStream(decompress)] =<= [NetworkStream] =<=>= ... Internet ...
(symétrique coté client)

Avec ce fonctionnement, les ReadLine des StreamReader bloquent des deux côtés... une idée ?


Sinon, comment faire pour garder les StreamReader tout en compressant le flux ?

Il faut que tu décompresses et compresses dans des flux auxiliaires, tels qu'un MemoryStream. Tu envoies ensuite ces bytes, avec préalablement la taille des données à recevoir de l'autre côté (bah oui il doit savoir en clair quel est la taille des données compressées).

[StreamWriter] => [GZipStream(Compress)] =>[MemoryStream]
[MemoryStream] -> [NetworkStream]

[NetworkStream] -> [MemoryStream]
[MemoryStream] <= GZipStream(Decompress)] <= [StreamReader].

L'utilisation ici des BinaryWriter et BinaryReader est nettement plus conseillée, car elle est plus souple et plus simple à mettre en place.

Attention, les outils Microsoft sont terriblement inefficaces. N'essaie pas de compresser un fichier sauf si avec un vrai compresseur il aurait un taux de compression d'au moins 50%.

En fait, le but n'est pas de faire de la compression de fichiers...
Le but est de passer d'un flux tcp en texte clair (un flux telnet) vers un flux compressé pour que la bande passante utilisée soit réduite.

Une première solution consisterai à effectivement passer par un mécanisme de compression en mémoire, mais pas que...

A mon avis, je vais encore devoir me bricoler un truc à la "pas propre" pour arriver à faire ce que je veux...

Pourquoi  ce monde n'est pas parfait ?