Discussion :

[xankow]

Bonjour,

je suis en train de developper une application serveur client. J'ai des messages de petites tailles mais nombreux a envoyer a mon client. Le probleme c'est que l'algorithme de Nagle transformes ces messages en un seul message les regroupant par groupe. C'est normalement tres interessant, mais dans cette application ca devient tres genant.

Je ne sais pas comment faire une trame par message.
Merci de votre aide.

[neptune]

En appelant Flush() après chaque message?

[xankow]

merci de ta reponse aussi rapide.

Je ne vois pas bien comment utiliser les Flush.
J'utilise des socket sous le framwork 1.1 de visual.

Mon code:

byte[] data =System.Text.Encoding.ASCII.GetBytes(trame1);
monSocket.Send(data, 0, data.Length,SocketFlags.None);

data =System.Text.Encoding.ASCII.GetBytes(trame2);
monSocket.Send(data, 0, data.Length,SocketFlags.None);

Le probleme c'est que mes trames 1 et 2 arrivent a mon client en une seule trame.

Petite precision: je suis un novice en reseau et en c#, ce qui n'aide en rien

[neptune]

Autant pour moi, il n'y a pas de Flush sur les Sockets mais bien sur les NetworkStream (Flush() qui ne fait rien d'ailleurs).

Essaie (sans garantie) de mettre le SendBufferSize de ton socket à la taille de ta trame avant de l'envoyer.

[xankow]

Le probleme c'est que mon appli dialogue avec des robots, et qu'ils n'envoient pas de trames de tailles fixes, elles dependent du message. Ta solution n'est pas vraiment adapter a mon cas precis.
Merci de t'etre penché sur mon probleme.

Faute de mieux je vais quand meme essayer ta solution. Meme si changer la taille du buffer a chaque message ne me plaie pas vraiment.

Sinon j'ai trouvé ca:

Code :

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

monSocket.SetSocketOption(SocketOptionLevel.Tcp, SocketOptionName.NoDelay, 1);

mais je ne vois pas comment ca marche, et la msdn n'est pas assez claire pour moi.

[neptune]

Le probleme c'est que mon appli dialogue avec des robots, et qu'ils n'envoient pas de trames de tailles fixes, elles dependent du message. Ta solution n'est pas vraiment adapter a mon cas precis.
Merci de t'etre penché sur mon probleme.

Code :

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

1
2
3
4
5
6
7
byte[] data =System.Text.Encoding.ASCII.GetBytes(trame1);
monSocket.SendBufferSize(data.Length);
monSocket.Send(data, 0, data.Length,SocketFlags.None);

data =System.Text.Encoding.ASCII.GetBytes(trame2);
monSocket.SendBufferSize(data.Length);
monSocket.Send(data, 0, data.Length,SocketFlags.None);

[xankow]

msdn:
"La propriété SendBufferSize obtient ou définit le nombre d'octets que vous prévoyez d'envoyer dans chaque appel à la méthode NetworkStream.Write. "

c'est pas encore la solution.

[Apocalyps]

Heu juste une petite réponse bête, et si tu réinitialisai l'objet socket après l'envoie du premier message ?

ce qui te donnerai :

Code :

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

1
2
3
4
5
6
7
8
9
10
byte[] data =System.Text.Encoding.ASCII.GetBytes(trame1);
monSocket1.Send(data, 0, data.Length,SocketFlags.None);
monsocket1.Close()

... monsocket2 = new ...

data =System.Text.Encoding.ASCII.GetBytes(trame2);
monSocket2.Send(data, 0, data.Length,SocketFlags.None);
monsocket2.Close()

Et pour chaque message tu recrée un objet socket (même si tu utilise le même nom pour chaque socket à condition que tu ai bien fermé le précédent).

[xankow]

Merci pour ta solution. Elle est adaptee a mon probleme pour le moment.
Mais cela implique que je ne pourai pas accepter plusieurs clients par la suite. En fermant le socket a chaque fois, je ne pourrai pas identifier mes clients en fonction de leur sockets.

Je vais prendre ca pour le moment, ca me permet de continuer mes essais. Mais plus tard j'aimerai pouvoir ajouter des clients.

Merci a tous de votre participation et de votre temps.

[theMonz31]

salut

normalement, avec les options que tu as présentés, on peut désactiver l'algo de nagles

Donc, noDelay devrait faire l'affaire (à moins qu'il y a une autre option à activer)

The Monz, Toulouse

[xankow]

Je pensais aussi avoir trouvé la solution. Mais le resultat n'est pas concluant

Mais je ne vois pas la difference. Mes message arrivent quand meme groupés.

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
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
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
 
using System;
using System.Reflection;
using System.Windows.Forms;
using System.Net.Sockets;
using System.Threading;
using System.IO;
using System.Net;
using System.Data;
 
namespace SEA
{
	public class ComEthServeur
	{
		#region Membres privés
 
		private Socket monSocket;
		private IPAddress adresse_Ip;
		private string nom_Machine;
		public TcpListener serveur;
		public System.Threading.Thread threadSurveillanceTcp;
		private Boolean arretThread;
 
		private	Boolean isConnected;
		public Boolean IsConnected
		{
			get { return isConnected; }			
		}
 
		private void surveille()
		{
			arretThread=false;			
			try
			{				
				//demarage du listener
				serveur = new TcpListener(port);
				serveur.Start();
 
				monSocket = serveur.AcceptSocket();
				this.isConnected=true;
 
				while(!arretThread)
				{
					if(serveur.Pending())
						monSocket = serveur.AcceptSocket();
 
					monSocket.SetSocketOption(System.Net.Sockets.SocketOptionLevel.Tcp, System.Net.Sockets.SocketOptionName.ReceiveBuffer, 0);
					byte[] option = monSocket.GetSocketOption(System.Net.Sockets.SocketOptionLevel.Tcp, System.Net.Sockets.SocketOptionName.NoDelay,1);
			//		monSocket.Send(option, 0, option.Length,SocketFlags.None);
 
 
			//		monSocket.IOControl
 
					if (monSocket.Available!=0)					
						OnReceptionData(this,new System.EventArgs());					
					Thread.Sleep(10);
				}
				Thread.Sleep(10);
				this.isConnected=false;
			}
			catch(Exception e)
			{
				this.isConnected=false;
				this.serveur.Stop();
				threadSurveillanceTcp.Abort();
 
				threadSurveillanceTcp = new Thread(new ThreadStart(surveille));
				threadSurveillanceTcp.Start();
			}
		}
 
		#endregion
 
		#region Proprietés
 
		private Boolean donneeLue;
 
		public Boolean DonneeLue
		{
			get { return donneeLue; }
		}
		private int port= new int();
 
		public int Port
		{
			get { return port; }
			set { port = value; }
		}		
		#endregion	
 
		#region Evenements
 
		public event EventHandler OnReceptionData;
 
 
		public event EventHandler OnClientConnected;
 
		#endregion
 
		#region Methodes
 
		public ComEthServeur()
		{		
		}
 
		public void Initialisation(int port)
		{
			this.isConnected=false;
			//Récupération de l'adresse Ip de la machine
			adresse_Ip = Dns.Resolve(Dns.GetHostName()).AddressList[0];
			//Récupération du nom de la machine
			nom_Machine = Dns.GetHostName().ToString();
 
			//port
			this.port=port;
 
			//demarage thread connectionClient
			threadSurveillanceTcp = new Thread(new ThreadStart(surveille));
			threadSurveillanceTcp.Start();
		}
 
		public void Initialisation()
		{
			this.isConnected=false;
			//Récupération de l'adresse Ip de la machine
			adresse_Ip = Dns.Resolve(Dns.GetHostName()).AddressList[0];
			//Récupération du nom de la machine
			nom_Machine = Dns.GetHostName().ToString();
 
			//demarage thread connectionClient
			threadSurveillanceTcp = new Thread(new ThreadStart(surveille));
			threadSurveillanceTcp.Start();
		}
 
		public Boolean Deconnection()
		{
			Boolean ok=true;
			try
			{
				arretThread=true;
				threadSurveillanceTcp.Abort();
 
				this.serveur.Stop();
				this.serveur=null;
				monSocket = null;
			}
			catch(Exception e)
			{
				ok=false;
			}
			return ok;
		}
 
 
		public Boolean EnvoiTrame(string trame)
		{
			Boolean ok=true;
			try
			{
				trame+=(char)10;
				byte[] data =System.Text.Encoding.ASCII.GetBytes(trame);
				monSocket.Send(data, 0, data.Length,SocketFlags.None);
			}
			catch(Exception e)
			{
				ok=false;
			//	clsLog.LogErreur(e);			
			}
			return ok;		
		}
 
		public Boolean EnvoiTrame(byte[] trame)
		{
			Boolean ok=true;
			try
			{		
		monSocket.SetSocketOption(System.Net.Sockets.SocketOptionLevel.Tcp, System.Net.Sockets.SocketOptionName.NoDelay, 1);
				monSocket.Send(trame, 0, trame.Length,SocketFlags.None);
			}
			catch(Exception e)
			{
				ok=false;
 
			}
			return ok;		
		}
 
		public Boolean LireTrame(out string trame)
		{
			Boolean ok=true;
			trame=String.Empty;
 
			try
			{
				Byte[] transfert = new Byte[2048];
				monSocket.Receive(transfert);
				trame = System.Text.Encoding.ASCII.GetString(transfert);
				donneeLue=true;
				//Se produit dès que le client se déconnecte
				if (trame.Substring(0,1)!="D")
				{
					serveur.Stop();
					threadSurveillanceTcp.Abort();
					threadSurveillanceTcp = new Thread(new ThreadStart(surveille));
					threadSurveillanceTcp.Start();
					threadSurveillanceTcp.Join(500);
				}
			}
			catch(Exception e)
			{
				ok=false;
			//	clsLog.LogErreur(e);			
			}
			return ok;		
		}
 
		public Boolean LireTrame(out byte[] trame)
		{
			Boolean ok=true;
			trame = new Byte[2048];
			try
			{
				monSocket.Receive(trame);
				donneeLue=true;
 
				//Se produit dès que le client se déconnecte
				if ( Convert.ToChar(trame[0])!='D' )
				{
					serveur.Stop();
					threadSurveillanceTcp.Abort();
					threadSurveillanceTcp = new Thread(new ThreadStart(surveille));
					threadSurveillanceTcp.Start();
					threadSurveillanceTcp.Join(500);
				}
			}
			catch(Exception e)
			{
				ok=false;
			}
			return ok;		
		}
		#endregion
	}
}

Je vous forni mon code. C'est peut etre moi qui fait n'importe quoi.

[theMonz31]

salut

et tu le fais ou le

SetSocketOption() pour le NoDelay ? parce que dans ton code, tu fais un GetOption() et non un set pour le noDelay !!! Je me trompe ou quoi ?

The Monz, Toulouse

[xankow]

Je fais un setsocketoption() dans :
public Boolean EnvoiTrame(byte[] trame){....}

C'est peut etre pas sa place ??

[theMonz31]

Je reitère ma question, tu nous a montré un bout de code :

Code :

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

1
2
3
 
monSocket.SetSocketOption(System.Net.Sockets.SocketOptionLevel.Tcp, System.Net.Sockets.SocketOptionName.ReceiveBuffer, 0);
					byte[] option = monSocket.GetSocketOption(System.Net.Sockets.SocketOptionLevel.Tcp, System.Net.Sockets.SocketOptionName.NoDelay,1);

Dans ce code, je vois un Set... pour le mode TCP, mais pour le no Delay, je
lis un Get.... donc, pour moi, tu ne fais pas ton Set pour le NoDelay

The Monz, Toulouse

[xankow]

Salut,

tu as entierement raison. J'ai fais une mauvaise modification, et le nodelay a disparu. J'aurai du ecrire (enfin je crois) :

Code :

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

 monSocket.SetSocketOption(System.Net.Sockets.SocketOptionLevel.Tcp, System.Net.Sockets.SocketOptionName.NoDelay, 0);

mais ca ne marche pas non plus

[sCove]

Salut,

tu as entierement raison. J'ai fais une mauvaise modification, et le nodelay a disparu. J'aurai du ecrire (enfin je crois) :

Code :

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

 monSocket.SetSocketOption(System.Net.Sockets.SocketOptionLevel.Tcp, System.Net.Sockets.SocketOptionName.NoDelay, 0);

mais ca ne marche pas non plus

Je pense que ce qui est cité precedement désactive le Nodelay et active l'envoi groupé.

Personnellement j'écrirais :

Code :

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

(System.Net.Sockets.SocketOptionLevel.Tcp, System.Net.Sockets.SocketOptionName.NoDelay, 1)

[xankow]

Merci,
j'ai suivi ton conseil.
En fait lors de mon execution, j'ai toujours des paquets qui se colle. Je ne vois pas bien la difference dans mon application.