美图齐众专注资阳网站设计 资阳网站制作 资阳网站建设
资阳网站建设公司服务热线：028-86922220

网站建设知识

十年网站开发经验 + 多家企业客户 + 靠谱的建站团队

量身定制 + 运营维护+专业推广+无忧售后，网站问题一站解决

浅析C#异步套接字的实现过程

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

创新互联公司-专业网站定制、快速模板网站建设、高性价比平昌网站开发、企业建站全套包干低至880元,成熟完善的模板库,直接使用。一站式平昌网站制作公司更省心,省钱,快速模板网站建设找我们，业务覆盖平昌地区。费用合理售后完善，10余年实体公司更值得信赖。

下面的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< EOF>");       
    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. 
  
  
  
  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("< EOF>") > -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#异步套接字有所帮助。

【编辑推荐】

  1. 总结C#语言命名规范
  2. C#反射相关知识学习
  3. 大话F#和C#：是否会重蹈C#失败的覆辙？
  4. 总结和学习C#接口
  5. 学习C#程序有感

分享标题：浅析C#异步套接字的实现过程
本文URL：http://www.zsjierui.cn/article/djdccsh.html

其他资讯