PageRenderTime 35ms CodeModel.GetById 12ms RepoModel.GetById 0ms app.codeStats 0ms

/SimpleTcp/SimpleTcpServer/Program.cs

https://code.google.com/p/prjtest00/
C# | 352 lines | 199 code | 47 blank | 106 comment | 29 complexity | fec5b958b9a0d713434b8261d6a55c3c MD5 | raw file
Possible License(s): GPL-2.0, GPL-3.0
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Net;
  6. using System.Net.Sockets;
  7. using System.Threading;
  8. using System.Diagnostics;
  9. namespace SimpleTcpServer
  10. {
  11. public class clSession
  12. {
  13. public int _ID;
  14. public Socket _Socket;
  15. public clSession(Socket ClientSocket)
  16. {
  17. Debug.Assert(ClientSocket != null);
  18. _Socket = ClientSocket;
  19. _ID = (int)ClientSocket.Handle;
  20. }
  21. public void Close()
  22. {
  23. Debug.Assert(_Socket != null);
  24. _Socket.Shutdown(SocketShutdown.Both);
  25. _Socket.Close();
  26. }
  27. }
  28. class TcpServer
  29. {
  30. public const int DefaultMaxClient = 5;
  31. public const int DefaultRecvBuffSize = 4 * 1024;
  32. private bool _bRun;
  33. private ushort _Port;
  34. private ushort _MaxClient;
  35. private TcpListener _Listener;
  36. private Dictionary<int, clSession> _dicSession;
  37. private byte[] _RecvBuff;
  38. protected void DoAcceptSocketCallback(IAsyncResult Result)
  39. {
  40. if (!_bRun)
  41. {
  42. Console.WriteLine("Server is not running...!!");
  43. return;
  44. }
  45. // Get the listener that handles the client request.
  46. TcpListener listener = (TcpListener)Result.AsyncState;
  47. // End the operation and display the received data on the
  48. //console.
  49. Socket NewSocket = listener.EndAcceptSocket(Result);
  50. // Process the connection here. (Add the client to a
  51. // server table, read data, etc.)
  52. if (_dicSession.Count() < _MaxClient)
  53. {
  54. _dicSession.Add((int)NewSocket.Handle, new clSession(NewSocket));
  55. Console.WriteLine("One client connected. Session ID = {0}", (int)NewSocket.Handle);
  56. NewSocket.BeginReceive(_RecvBuff, 0, _RecvBuff.Length, SocketFlags.None, new AsyncCallback(DoReceiveCallback), NewSocket);
  57. }
  58. else
  59. Console.WriteLine("Server is full!!");
  60. _Listener.BeginAcceptSocket(new AsyncCallback(DoAcceptSocketCallback), _Listener);
  61. }
  62. protected void DoReceiveCallback(IAsyncResult Result)
  63. {
  64. Socket ClientSocket = (Socket)Result.AsyncState;
  65. try
  66. {
  67. int RecvSize = ClientSocket.EndReceive(Result);
  68. if (RecvSize == 0)
  69. {
  70. CloseClient(ClientSocket);
  71. return;
  72. }
  73. Console.WriteLine("[{0}][Receive Message]: {1}", (int)ClientSocket.Handle, Encoding.ASCII.GetString(_RecvBuff, 0, RecvSize));
  74. ClientSocket.BeginReceive(_RecvBuff, 0, _RecvBuff.Length, SocketFlags.None, new AsyncCallback(DoReceiveCallback), ClientSocket);
  75. }
  76. catch (SocketException ex)
  77. {
  78. if (ex.ErrorCode == 10054)
  79. CloseClient(ClientSocket);
  80. }
  81. catch (ObjectDisposedException ex)
  82. {
  83. if (ex != null)
  84. ex = null;
  85. }
  86. }
  87. public TcpServer(ushort Port): this(Port, DefaultMaxClient)
  88. {
  89. }
  90. public TcpServer(ushort Port, ushort MaxClient)
  91. {
  92. _Port = Port;
  93. _MaxClient = MaxClient;
  94. }
  95. public void Start()
  96. {
  97. if (_bRun)
  98. {
  99. Console.WriteLine("Server is running...!!");
  100. return;
  101. }
  102. _dicSession = new Dictionary<int, clSession>(_MaxClient);
  103. _RecvBuff = new byte[DefaultRecvBuffSize];
  104. //System.Net.IPAddress theIPAddress;
  105. ////?? IPAddress ??(??)
  106. //theIPAddress = System.Net.IPAddress.Parse("127.0.0.1");
  107. //_Listener = new TcpListener(theIPAddress, _Port);
  108. IPAddress ipAddress = Dns.Resolve("localhost").AddressList[0];
  109. _Listener = new TcpListener(ipAddress, _Port);
  110. _Listener.Start();
  111. _Listener.BeginAcceptSocket(new AsyncCallback(DoAcceptSocketCallback), _Listener);
  112. Console.WriteLine("Server Started...Listen at {0}...!!", _Listener.LocalEndpoint.ToString());
  113. _bRun = true;
  114. }
  115. public void Stop()
  116. {
  117. if (!_bRun)
  118. {
  119. Console.WriteLine("Server is not running...!!");
  120. return;
  121. }
  122. _bRun = false;
  123. _Listener.Stop();
  124. CloseAllClient();
  125. _dicSession = null;
  126. }
  127. public void Send(int SessionID, string Message)
  128. {
  129. clSession session = _dicSession[SessionID];
  130. if (session != null)
  131. {
  132. //byte[] data = _coder.GetEncodingBytes(datagram);
  133. Byte[] data = Encoding.ASCII.GetBytes(Message);
  134. //session._Socket.BeginSend(data, 0, data.Length, SocketFlags.None,
  135. // new AsyncCallback(SendDataEnd), session._Socket);
  136. //session._Socket.BeginSend(data, 0, data.Length, SocketFlags.None,
  137. //new AsyncCallback(SendDataEnd), session._Socket);
  138. session._Socket.Send(data, data.Length, 0);
  139. }
  140. }
  141. public void Broadcast(string Message)
  142. {
  143. Byte[] data = Encoding.ASCII.GetBytes(Message);
  144. foreach (clSession session in _dicSession.Values)
  145. session._Socket.Send(data, data.Length, 0);
  146. }
  147. public void CloseClient(Socket ClientSocket)
  148. {
  149. clSession session = _dicSession[(int)ClientSocket.Handle];
  150. session.Close();
  151. _dicSession.Remove((int)ClientSocket.Handle);
  152. Console.WriteLine("Session[{0}] is disconnected!!", (int)ClientSocket.Handle);
  153. }
  154. public void CloseAllClient()
  155. {
  156. foreach (clSession session in _dicSession.Values)
  157. session.Close();
  158. _dicSession.Clear();
  159. }
  160. }
  161. class Program
  162. {
  163. //public static void AcceptWorker(object Params)
  164. //{
  165. // Console.WriteLine("Accept Thread Starts.");
  166. // TcpListener Listener = (TcpListener)Params;
  167. // while (true)
  168. // {
  169. // Socket NewSocket = Listener.AcceptSocket();
  170. // if (NewSocket.Connected)
  171. // {
  172. // Console.WriteLine("???? !!");
  173. // clSession NewState = new clSession(NewSocket);
  174. // //NewState.ConnectionSocket = NewSocket;
  175. // Thread RecvThread = new Thread(Program.RecvWorker);
  176. // RecvThread.IsBackground = true;
  177. // RecvThread.Start(NewState);
  178. // }
  179. // }
  180. //}
  181. //public static void RecvWorker(object Params)
  182. //{
  183. // clSession state = (clSession)Params;
  184. // Console.WriteLine("Recv Thread Starts.");
  185. // //NetworkStream NetworkStream;
  186. // int dataLength;
  187. // byte[] myBufferBytes = new byte[1000];
  188. // while (true)
  189. // {
  190. // try
  191. // {
  192. // //??????????
  193. // dataLength = state.ConnectionSocket.Receive(myBufferBytes);
  194. // Console.WriteLine("???????? {0} \n ", dataLength.ToString());
  195. // Console.WriteLine("????????????????? :");
  196. // Console.WriteLine(Encoding.ASCII.GetString(myBufferBytes, 0, dataLength) + "\n");
  197. // //Console.WriteLine("?? [???] ????????? !!");
  198. // //Console.ReadLine();
  199. // //?????????????
  200. // //state.ConnectionSocket.Send(myBufferBytes, myBufferBytes.Length, 0);
  201. // state.ConnectionSocket.Send(myBufferBytes, dataLength, 0);
  202. // System.Threading.Thread.Sleep(100);
  203. // }
  204. // catch (Exception e)
  205. // {
  206. // Console.WriteLine(e.Message);
  207. // state.ConnectionSocket.Close();
  208. // break;
  209. // }
  210. // }
  211. //}
  212. static void Main(string[] args)
  213. {
  214. //System.Net.IPAddress theIPAddress;
  215. ////?? IPAddress ??(??)
  216. //theIPAddress = System.Net.IPAddress.Parse("127.0.0.1");
  217. ////??????
  218. //TcpListener Listener = new TcpListener(theIPAddress, 36000);
  219. ////????
  220. //Listener.Start();
  221. //Console.WriteLine("??? 36000 ???????...... !!");
  222. TcpServer tcpServer = new TcpServer(55000, 10);
  223. //Thread AcceptThread = new Thread(Program.AcceptWorker);
  224. //AcceptThread.IsBackground = true;
  225. //AcceptThread.Start(Listener);
  226. // Socket mySocket = myTcpListener.AcceptSocket();
  227. //do
  228. //{
  229. //try
  230. //{
  231. // //??????????????????
  232. // //?????????????????
  233. // if (mySocket.Connected)
  234. // {
  235. // int dataLength;
  236. // Console.WriteLine("???? !!");
  237. // byte[] myBufferBytes = new byte[1000];
  238. // //??????????
  239. // dataLength = mySocket.Receive(myBufferBytes);
  240. // Console.WriteLine("???????? {0} \n ", dataLength.ToString());
  241. // Console.WriteLine("????????????????? :");
  242. // Console.WriteLine(Encoding.ASCII.GetString(myBufferBytes, 0, dataLength) + "\n");
  243. // Console.WriteLine("?? [???] ????????? !!");
  244. // Console.ReadLine();
  245. // //?????????????
  246. // mySocket.Send(myBufferBytes, myBufferBytes.Length, 0);
  247. // }
  248. //}
  249. //catch (Exception e)
  250. //{
  251. // Console.WriteLine(e.Message);
  252. // mySocket.Close();
  253. // break;
  254. //}
  255. //} while (true);
  256. while (true)
  257. {
  258. //Console.Write(">");
  259. string cmd = Console.ReadLine();
  260. //??????
  261. if (cmd.ToLower() == "exit")
  262. {
  263. tcpServer.Stop();
  264. break;
  265. }
  266. if (cmd.ToLower() == "start")
  267. {
  268. tcpServer.Start();
  269. continue;
  270. }
  271. if (cmd.ToLower() == "stop")
  272. {
  273. tcpServer.Stop();
  274. Console.WriteLine("Server is Stop.");
  275. continue;
  276. }
  277. if (cmd.ToLower().IndexOf("send") != -1)
  278. {
  279. cmd = cmd.ToLower();
  280. string[] para = cmd.Split(' ');
  281. if (para.Length == 3)
  282. tcpServer.Send(int.Parse(para[1]), para[2]);
  283. else
  284. {
  285. Console.WriteLine("Error Command");
  286. }
  287. continue;
  288. }
  289. if (cmd.ToLower().IndexOf("bc") != -1)
  290. {
  291. cmd = cmd.ToLower();
  292. string[] para = cmd.Split(' ');
  293. if (para.Length == 2)
  294. tcpServer.Broadcast(para[1]);
  295. else
  296. {
  297. Console.WriteLine("Error Command");
  298. }
  299. continue;
  300. }
  301. Console.WriteLine("Unkown Command");
  302. }//end of while
  303. }
  304. }
  305. }