C#异步套接字实现浅析

C#异步套接字实现是如何的呢？让我们开始从实例开始：

下面的C#异步套接字实现实例程序创建一个连接到服务器的客户端。该客户端是用C#异步套接字生成的，因此在等待服务器返回响应时不挂起客户端应用程序的执行。该应用程序将字符串发送到服务器，然后在控制台显示该服务器返回的字符串。

 
 
 
    
  
  
  
  1. using System;  
    2. 
  
  
  
  2. using System.Net;  
    3. 
  
  
  
  3. using System.Net.Sockets;  
    4. 
  
  
  
  4. using System.Threading;  
    5. 
  
  
  
  5. using System.Text;  
    6. 
  
  
  
  6. // State object for receiving data from remote device.  
    7. 
  
  
  
  7. public class StateObject {  
    8. 
  
  
  
  8. // Client socket.  
    9. 
  
  
  
  9. public Socket workSocket = null;  
    10. 
  
  
  
  10. // Size of receive buffer.  
    11. 
  
  
  
  11. public const int BufferSize = 256;  
    12. 
  
  
  
  12. // Receive buffer.  
    13. 
  
  
  
  13. public byte[] buffer = new byte[BufferSize];  
    14. 
  
  
  
  14. // Received data string.  
    15. 
  
  
  
  15. public StringBuilder sb = new StringBuilder();  
    16. 
  
  
  
  16. }  
    17. 
  
  
  
  17. public class AsynchronousClient {  
    18. 
  
  
  
  18. // The port number for the remote device.  
    19. 
  
  
  
  19. private const int port = 11000;  
    20. 
  
  
  
  20. // ManualResetEvent instances signal completion.  
    21. 
  
  
  
  21. private static ManualResetEvent connectDone =  
    22. 
  
  
  
  22. new ManualResetEvent(false);  
    23. 
  
  
  
  23. private static ManualResetEvent sendDone =  
    24. 
  
  
  
  24. new ManualResetEvent(false);  
    25. 
  
  
  
  25. private static ManualResetEvent receiveDone =  
    26. 
  
  
  
  26. new ManualResetEvent(false);  
    27. 
  
  
  
  27. // The response from the remote device.  
    28. 
  
  
  
  28. private static String response = String.Empty;  
    29. 
  
  
  
  29. private static void StartClient() {  
    30. 
  
  
  
  30. // Connect to a remote device.  
    31. 
  
  
  
  31. try {  
    32. 
  
  
  
  32. // Establish the remote endpoint for the socket.  
    33. 
  
  
  
  33. // The name of the  
    34. 
  
  
  
  34. // remote device is "host.contoso.com".  
    35. 
  
  
  
  35. IPHostEntry ipHostInfo = Dns.Resolve("host.contoso.com");  
    36. 
  
  
  
  36. IPAddress ipAddress = ipHostInfo.AddressList[0];  
    37. 
  
  
  
  37. IPEndPoint remoteEP = new IPEndPoint(ipAddress, port);  
    38. 
  
  
  
  38. // Create a TCP/IP socket.  
    39. 
  
  
  
  39. Socket client = new Socket(AddressFamily.InterNetwork,  
    40. 
  
  
  
  40. SocketType.Stream, ProtocolType.Tcp);  
    41. 
  
  
  
  41. // Connect to the remote endpoint.  
    42. 
  
  
  
  42. client.BeginConnect( remoteEP,  
    43. 
  
  
  
  43. new AsyncCallback(ConnectCallback), client);  
    44. 
  
  
  
  44. connectDone.WaitOne();  
    45. 
  
  
  
  45. // Send test data to the remote device.  
    46. 
  
  
  
  46. Send(client,"This is a test");  
    47. 
  
  
  
  47. sendDone.WaitOne();  
    48. 
  
  
  
  48. // Receive the response from the remote device.  
    49. 
  
  
  
  49. Receive(client);  
    50. 
  
  
  
  50. receiveDone.WaitOne();  
    51. 
  
  
  
  51. // Write the response to the console.  
    52. 
  
  
  
  52. Console.WriteLine("Response received : {0}", response);  
    53. 
  
  
  
  53. // Release the socket.  
    54. 
  
  
  
  54. client.Shutdown(SocketShutdown.Both);  
    55. 
  
  
  
  55. client.Close();  
    56. 
  
  
  
  56. } catch (Exception e) {  
    57. 
  
  
  
  57. Console.WriteLine(e.ToString());  
    58. 
  
  
  
  58. }  
    59. 
  
  
  
  59. }  
    60. 
  
  
  
  60. private static void ConnectCallback(IAsyncResult ar) {  
    61. 
  
  
  
  61. try {  
    62. 
  
  
  
  62. // Retrieve the socket from the state object.  
    63. 
  
  
  
  63. Socket client = (Socket) ar.AsyncState;  
    64. 
  
  
  
  64. // Complete the connection.  
    65. 
  
  
  
  65. client.EndConnect(ar);  
    66. 
  
  
  
  66. Console.WriteLine("Socket connected to {0}",  
    67. 
  
  
  
  67. client.RemoteEndPoint.ToString());  
    68. 
  
  
  
  68. // Signal that the connection has been made.  
    69. 
  
  
  
  69. connectDone.Set();  
    70. 
  
  
  
  70. } catch (Exception e) {  
    71. 
  
  
  
  71. Console.WriteLine(e.ToString());  
    72. 
  
  
  
  72. }  
    73. 
  
  
  
  73. }  
    74. 
  
  
  
  74. private static void Receive(Socket client) {  
    75. 
  
  
  
  75. try {  
    76. 
  
  
  
  76. // Create the state object.  
    77. 
  
  
  
  77. StateObject state = new StateObject();  
    78. 
  
  
  
  78. state.workSocket = client;  
    79. 
  
  
  
  79. // Begin receiving the data from the remote device.  
    80. 
  
  
  
  80. client.BeginReceive( state.buffer, 0, StateObject.BufferSize, 0,  
    81. 
  
  
  
  81. new AsyncCallback(ReceiveCallback), state);  
    82. 
  
  
  
  82. } catch (Exception e) {  
    83. 
  
  
  
  83. Console.WriteLine(e.ToString());  
    84. 
  
  
  
  84. }  
    85. 
  
  
  
  85. }  
    86. 
  
  
  
  86. private static void ReceiveCallback( IAsyncResult ar ) {  
    87. 
  
  
  
  87. try {  
    88. 
  
  
  
  88. // Retrieve the state object and the client socket  
    89. 
  
  
  
  89. // from the asynchronous state object.  
    90. 
  
  
  
  90. StateObject state = (StateObject) ar.AsyncState;  
    91. 
  
  
  
  91. Socket client = state.workSocket;  
    92. 
  
  
  
  92. // Read data from the remote device.  
    93. 
  
  
  
  93. int bytesRead = client.EndReceive(ar);  
    94. 
  
  
  
  94. if (bytesRead > 0) {  
    95. 
  
  
  
  95. // There might be more data, so store the data received so far.  
    96. 
  
  
  
  96. 
  
  
  
  97. state.sb.Append(Encoding.ASCII.GetString( 
    98. 
  
  
  
  98. state.buffer,0,bytesRead));  
    99. 
  
  
  
  99. // Get the rest of the data.  
    100. 
  
  
  
  100. client.BeginReceive(state.buffer,0,StateObject.BufferSize,0,  
    101. 
  
  
  
  101. new AsyncCallback(ReceiveCallback), state);  
    102. 
  
  
  
  102. } else {  
    103. 
  
  
  
  103. // All the data has arrived; put it in response.  
    104. 
  
  
  
  104. if (state.sb.Length > 1) {  
    105. 
  
  
  
  105. response = state.sb.ToString();  
    106. 
  
  
  
  106. }  
    107. 
  
  
  
  107. // Signal that all bytes have been received.  
    108. 
  
  
  
  108. receiveDone.Set();  
    109. 
  
  
  
  109. }  
    110. 
  
  
  
  110. } catch (Exception e) {  
    111. 
  
  
  
  111. Console.WriteLine(e.ToString());  
    112. 
  
  
  
  112. }  
    113. 
  
  
  
  113. }  
    114. 
  
  
  
  114. private static void Send(Socket client, String data) {  
    115. 
  
  
  
  115. // Convert the string data to byte data using ASCII encoding.  
    116. 
  
  
  
  116. byte[] byteData = Encoding.ASCII.GetBytes(data);  
    117. 
  
  
  
  117. // Begin sending the data to the remote device.  
    118. 
  
  
  
  118. client.BeginSend(byteData, 0, byteData.Length, 0,  
    119. 
  
  
  
  119. new AsyncCallback(SendCallback), client);  
    120. 
  
  
  
  120. }  
    121. 
  
  
  
  121. private static void SendCallback(IAsyncResult ar) {  
    122. 
  
  
  
  122. try {  
    123. 
  
  
  
  123. // Retrieve the socket from the state object.  
    124. 
  
  
  
  124. Socket client = (Socket) ar.AsyncState;  
    125. 
  
  
  
  125. // Complete sending the data to the remote device.  
    126. 
  
  
  
  126. int bytesSent = client.EndSend(ar);  
    127. 
  
  
  
  127. Console.WriteLine("Sent {0} bytes to server.", bytesSent);  
    128. 
  
  
  
  128. // Signal that all bytes have been sent.  
    129. 
  
  
  
  129. sendDone.Set();  
    130. 
  
  
  
  130. } catch (Exception e) {  
    131. 
  
  
  
  131. Console.WriteLine(e.ToString());  
    132. 
  
  
  
  132. }  
    133. 
  
  
  
  133. }  
    134. 
  
  
  
  134. public static int Main(String[] args) {  
    135. 
  
  
  
  135. StartClient();  
    136. 
  
  
  
  136. return 0;  
    137. 
  
  
  
  137. }  
    138. 
  
  
  
  138. } 
    139.

C#异步套接字在服务器的示例 下面的示例程序创建一个接收来自客户端的连接请求的服务器。该服务器是用C#异步套接字生成的

因此在等待来自客户端的连接时不挂起服务器应用程序的执行。该应用程序接收来自客户端的字符串

在控制台显示该字符串，然后将该字符串回显到客户端。来自客户端的字符串必须包含字符串“”

以发出表示消息结尾的信号。

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

C#异步套接字的相关内容就向你介绍到这里，希望对你了解和学习C#异步套接字有所帮助。

本文题目：C#异步套接字实现浅析
标题URL：http://www.shufengxianlan.com/qtweb/news21/439771.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

手机网站建设知识

分类信息网站

成都小程序开发公司　　 　乐山网站建设　　 　重庆网站建设网络公司　　 　手机微信网站　　 　谷歌优化排名　　 　自贡主机托管　　 　成都小程序开发　　 　康明斯发电机　　 　成都服务器机柜租用　　 　崇州湖霆科技　　 　微信小程序　　 　二枢服务器托管　　 　网站建设改版　　 　网站设计　　 　攀枝花网站建设　　 　成都app开发　　 　成都小程序开发　　 　平武做网站　　 　成都包装设计公司　　 　云主机