Buenas, tengo el siguiente servidor de Sockets, que trabaja de forma asincronica y acepta multiples clientes conectados a la vez. El mismo lo saque de la web de microsoft.

Al codigo del ejemplo le realize unas pequenias modificaciones en la parte de la configuracion de la IPAddress y el Puerto.


1. using System;
2. using System.Net;
3. using System.Net.Sockets;
4. using System.Text;
5. using System.Threading;
6.
7. // State object for reading client data asynchronously
8. public class StateObject
9. {
10. // Client socket.
11. public Socket workSocket = null;
12. // Size of receive buffer.
13. public const int BufferSize = 1024;
14. // Receive buffer.
15. public byte[] buffer = new byte[BufferSize];
16. // Received data string.
17. public StringBuilder sb = new StringBuilder();
18. }
19.
20. public class AsynchronousSocketListener
21. {
22.
23. // Incoming data from client.
24. public static string data = null;
25.
26. // Thread signal.
27. public static ManualResetEvent allDone = new ManualResetEvent(false);
28.
29. public AsynchronousSocketListener()
30. {
31. }
32.
33. public static void StartListening()
34. {
35. // Data buffer for incoming data.
36. byte[] bytes = new Byte[1024];
37.
38. // Establish the local endpoint for the socket.
39. // The DNS name of the computer
40. // running the listener is "host.contoso.com".
41. IPAddress ipAddress = Dns.GetHostEntry("192.168.1.33").AddressList[2];
42. IPEndPoint localEndPoint = new IPEndPoint(ipAddress, 4070);
43.
44. // Create a TCP/IP socket.
45. Socket listener = new Socket(AddressFamily.InterNetwork,
46. SocketType.Stream, ProtocolType.Tcp);
47.
48. // Bind the socket to the local endpoint and listen for incoming connections.
49. try
50. {
51. listener.Bind(localEndPoint);
52. listener.Listen(100);
53.
54. while (true)
55. {
56. // Set the event to nonsignaled state.
57. allDone.Reset();
58.
59. // Start an asynchronous socket to listen for connections.
60. Console.WriteLine("Waiting for a connection...");
61. listener.BeginAccept(
62. new AsyncCallback(AcceptCallback),
63. listener);
64.
65. // Wait until a connection is made before continuing.
66. allDone.WaitOne();
67. }
68.
69. }
70. catch (Exception e)
71. {
72. Console.WriteLine(e.ToString());
73. }
74.
75. Console.WriteLine("
Press ENTER to continue...");
76. Console.Read();
77.
78. }
79.
80. public static void AcceptCallback(IAsyncResult ar)
81. {
82. // Signal the main thread to continue.
83. allDone.Set();
84.
85. // Get the socket that handles the client request.
86. Socket listener = (Socket)ar.AsyncState;
87. Socket handler = listener.EndAccept(ar);
88.
89. // Create the state object.
90. StateObject state = new StateObject();
91. state.workSocket = handler;
92. handler.BeginReceive(state.buffer, , StateObject.BufferSize, ,
93. new AsyncCallback(ReadCallback), state);
94. }
95.
96. public static void ReadCallback(IAsyncResult ar)
97. {
98. String content = String.Empty;
99.
100. // Retrieve the state object and the handler socket
101. // from the asynchronous state object.
102. StateObject state = (StateObject)ar.AsyncState;
103. Socket handler = state.workSocket;
104.
105. // Read data from the client socket.
106. int bytesRead = handler.EndReceive(ar);
107.
108. if (bytesRead > )
109. {
110. // There might be more data, so store the data received so far.
111. state.sb.Append(Encoding.ASCII.GetString(
112. state.buffer, , bytesRead));
113.
114. // Check for end-of-file tag. If it is not there, read
115. // more data.
116. content = state.sb.ToString();
117. if (content.IndexOf("
") > -1)
118. {
119. // All the data has been read from the
120. // client. Display it on the console.
121. Console.WriteLine("Read {0} bytes from socket.
Data : {1}",
122. content.Length, content);
123. // Echo the data back to the client.
124. Send(handler, content);
125. }
126. else
127. {
128. // Not all data received. Get more.
129. handler.BeginReceive(state.buffer, , StateObject.BufferSize, ,
130. new AsyncCallback(ReadCallback), state);
131. }
132. }
133. }
134.
135. private static void Send(Socket handler, String data)
136. {
137. // Convert the string data to byte data using ASCII encoding.
138. byte[] byteData = Encoding.ASCII.GetBytes(data);
139.
140. // Begin sending the data to the remote device.
141. handler.BeginSend(byteData, , byteData.Length, ,
142. new AsyncCallback(SendCallback), handler);
143. }
144.
145. private static void SendCallback(IAsyncResult ar)
146. {
147. try
148. {
149. // Retrieve the socket from the state object.
150. Socket handler = (Socket)ar.AsyncState;
151.
152. // Complete sending the data to the remote device.
153. int bytesSent = handler.EndSend(ar);
154. Console.WriteLine("Sent {0} bytes to client.", bytesSent);
155.
156. handler.Shutdown(SocketShutdown.Both);
157. handler.Close();
158.
159. }
160. catch (Exception e)
161. {
162. Console.WriteLine(e.ToString());
163. }
164. }
165.
166.
167. public static int Main(String[] args)
168. {
169. StartListening();
170. return ;
171. }
172. }
173.



Ahora bien, asi como esta, el cliente se conecta a este servidor y envia un mensaje. El servidor lo lee, y luego desconecta al cliente. Yo necesito que el cliente siga conectado, y pueda seguir enviando cuantos mensajes quiera.

Por un lado se que tengo que remover las siguientes lineas del metodo SendCallBack, para que el cliente siga conectado:

handler.Shutdown(SocketShutdown.Both);
handler.Close();

En fin, como puedo hacer para que el cliente pueda seguir enviando mensajes? Hay que agregar un bucle? Donde?

Gracias!