使用.NET访问Internet(5)

同步客户端套接字示例

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

 [C#]
    
    

using System;
   
   

using System.Net;
   
   

using System.Net.Sockets;
   
   

using System.Text;
   
   

public class SynchronousSocketClient {
   
   

  public static void StartClient() {
   
   

    // Data buffer for incoming data.
   
   

    byte[] bytes = new byte[1024];
   
   

    // Connect to a remote device.
   
   

    try {
   
   

      // Establish the remote endpoint for the socket.
   
   

      //    The name of the
   
   

      //   remote device is "host.contoso.com".
   
   

      IPHostEntry ipHostInfo = Dns.Resolve("host.contoso.com");
   
   

      IPAddress ipAddress = ipHostInfo.AddressList[0];
   
   

      IPEndPoint remoteEP = new IPEndPoint(ipAddress,11000);
   
   

      // Create a TCP/IP  socket.
   
   

      Socket sender = new Socket(AddressFamily.InterNetwork, 
   
   

        SocketType.Stream, ProtocolType.Tcp );
   
   

      // Connect the socket to the remote endpoint. Catch any errors.
   
   

      try {
   
   

        sender.Connect(remoteEP);
   
   

        Console.WriteLine("Socket connected to {0}",
   
   

          sender.RemoteEndPoint.ToString());
   
   

        // Encode the data string into a byte array.
   
   

        byte[] msg = Encoding.ASCII.GetBytes("This is a test<EOF>");
   
   

        // Send the data through the  socket.
   
   

        int bytesSent = sender.Send(msg);
   
   

        // Receive the response from the remote device.
   
   

        int bytesRec = sender.Receive(bytes);
   
   

        Console.WriteLine("Echoed test = {0}",
   
   

          Encoding.ASCII.GetString(bytes,0,bytesRec));
   
   

        // Release the socket.
   
   

        sender.Shutdown(SocketShutdown.Both);
   
   

        sender.Close();
   
   

      } catch (ArgumentNullException ane) {
   
   

        Console.WriteLine("ArgumentNullException : {0}",ane.ToString());
   
   

      } catch (SocketException se) {
   
   

        Console.WriteLine("SocketException : {0}",se.ToString());
   
   

      } catch (Exception e) {
   
   

        Console.WriteLine("Unexpected exception : {0}", e.ToString());
   
   

      }
   
   

    } catch (Exception e) {
   
   

      Console.WriteLine( e.ToString());
   
   

    }
   
   

  }
   
   

  public static int Main(String[] args) {
   
   

    StartClient();
   
   

    return 0;
   
   

  }
   
   

}
   
   

同步服务器套接字示例

下面的示例程序创建一个接收来自客户端的连接请求的服务器。该服务器是用同步套接字生成的，因此在等待来自客户端的连接时不挂起服务器应用程序的执行。该应用程序接收来自客户端的字符串，在控制台显示该字符串，然后将该字符串回显到客户端。来自客户端的字符串必须包含字符串“<EOF>”，以发出表示消息结尾的信号。

 [C#]
    
    

using System;
   
   

using System.Net;
   
   

using System.Net.Sockets;
   
   

using System.Text;
   
   

public class SynchronousSocketListener {
   
   

  // Incoming data from the client.
   
   

  public static string data = null;
   
   

  public static void StartListening() {
   
   

    // Data buffer for incoming data.
   
   

    byte[] bytes = new Byte[1024];
   
   

    // Establish the local endpoint for the  socket.
   
   

    //  Dns.GetHostName returns the name of the 
   
   

    // host running the application.
   
   

    IPHostEntry ipHostInfo = Dns.Resolve(Dns.GetHostName());
   
   

    IPAddress ipAddress = ipHostInfo.AddressList[0];
   
   

    IPEndPoint localEndPoint = new IPEndPoint(ipAddress, 11000);
   
   

    // Create a TCP/IP socket.
   
   

    Socket listener = new Socket(AddressFamily.InterNetwork,
   
   

      SocketType.Stream, ProtocolType.Tcp );
   
   

    // Bind the socket to the local endpoint and 
   
   

    // listen for incoming connections.
   
   

    try {
   
   

      listener.Bind(localEndPoint);
   
   

      listener.Listen(10);
   
   

      // Start listening for connections.
   
   

      while (true) {
   
   

        Console.WriteLine("Waiting for a connection...");
   
   

        // Program is suspended while waiting for an incoming connection.
   
   

        Socket handler = listener.Accept();
   
   

        data = null;
   
   

        // An incoming connection needs to be processed.
   
   

        while (true) {
   
   

          bytes = new byte[1024];
   
   

          int bytesRec = handler.Receive(bytes);
   
   

          data += Encoding.ASCII.GetString(bytes,0,bytesRec);
   
   

          if (data.IndexOf("<EOF>") > -1) {
   
   

            break;
   
   

          }
   
   

        }
   
   

        // Show the data on the console.
   
   

        Console.WriteLine( "Text received : {0}", data);
   
   

        // Echo the data back to the client.
   
   

        byte[] msg = Encoding.ASCII.GetBytes(data);
   
   

        handler.Send(msg);
   
   

        handler.Shutdown(SocketShutdown.Both);
   
   

        handler.Close();
   
   

      }
   
   

    } catch (Exception e) {
   
   

      Console.WriteLine(e.ToString());
   
   

    }
   
   

    Console.WriteLine("/nHit enter to continue...");
   
   

    Console.Read();
   
   

  }
   
   

  public static int Main(String[] args) {
   
   

    StartListening();
   
   

    return 0;
   
   

  }
   
   

}
   
   

异步客户端套接字示例

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

 [C#]
    
    

using System;
   
   

using System.Net;
   
   

using System.Net.Sockets;
   
   

using System.Threading;
   
   

using System.Text;
   
   

// State object for receiving data from remote device.
   
   

public class StateObject {
   
   

  public Socket workSocket = null;              // Client socket.
   
   

  public const int BufferSize = 256;            // Size of receive buffer.
   
   

  public byte[] buffer = new byte[BufferSize];  // Receive buffer.
   
   

  public StringBuilder sb = new StringBuilder();// Received data string.
   
   

}
   
   

public class AsynchronousClient {
   
   

  // The port number for the remote device.
   
   

  private const int port = 11000;
   
   

  // ManualResetEvent instances signal completion.
   
   

  private static ManualResetEvent connectDone = 
   
   

    new ManualResetEvent(false);
   
   

  private static ManualResetEvent sendDone = 
   
   

    new ManualResetEvent(false);
   
   

  private static ManualResetEvent receiveDone = 
   
   

    new ManualResetEvent(false);
   
   

  // The response from the remote device.
   
   

  private static String response = String.Empty;
   
   

  private static void StartClient() {
   
   

    // Connect to a remote device.
   
   

    try {
   
   

      // Establish the remote endpoint for the socket.
   
   

      // "host.contoso.com" is the name of the
   
   

      // remote device.
   
   

      IPHostEntry ipHostInfo = Dns.Resolve("host.contoso.com");
   
   

      IPAddress ipAddress = ipHostInfo.AddressList[0];
   
   

      IPEndPoint remoteEP = new IPEndPoint(ipAddress, port);
   
   

      //  Create a TCP/IP  socket.
   
   

      Socket client = new Socket(AddressFamily.InterNetwork,
   
   

        SocketType.Stream, ProtocolType.Tcp);
   
   

      // Connect to the remote endpoint.
   
   

      client.BeginConnect( remoteEP, 
   
   

        new AsyncCallback(ConnectCallback), client);
   
   

      connectDone.WaitOne();
   
   

      // Send test data to the remote device.
   
   

      Send(client,"This is a test<EOF>");
   
   

      sendDone.WaitOne();
   
   

      // Receive the response from the remote device.
   
   

      Receive(client);
   
   

      receiveDone.WaitOne();
   
   

      // Write the response to the console.
   
   

      Console.WriteLine("Response received : {0}", response);
   
   

      // Release the socket.
   
   

      client.Shutdown(SocketShutdown.Both);
   
   

      client.Close();
   
   

    } catch (Exception e) {
   
   

      Console.WriteLine(e.ToString());
   
   

    }
   
   

  }
   
   

  private static void ConnectCallback(IAsyncResult ar) {
   
   

    try {
   
   

      // Retrieve the socket from the state object.
   
   

      Socket client = (Socket) ar.AsyncState;
   
   

      // Complete the connection.
   
   

      client.EndConnect(ar);
   
   

      Console.WriteLine("Socket connected to {0}",
   
   

        client.RemoteEndPoint.ToString());
   
   

      // Signal that the connection has been made.
   
   

      connectDone.Set();
   
   

    } catch (Exception e) {
   
   

      Console.WriteLine(e.ToString());
   
   

    }
   
   

  }
   
   

  private static void Receive(Socket client) {
   
   

    try {
   
   

      // Create the state object.
   
   

      StateObject state = new StateObject();
   
   

      state.workSocket = client;
   
   

      // Begin receiving the data from the remote device.
   
   

      client.BeginReceive( state.buffer, 0, StateObject.BufferSize, 0,
   
   

        new AsyncCallback(ReceiveCallback), state);
   
   

    } catch (Exception e) {
   
   

      Console.WriteLine(e.ToString());
   
   

    }
   
   

  }
   
   

  private static void ReceiveCallback( IAsyncResult ar ) {
   
   

    try {
   
   

      // Retrieve the state object and the client socket 
   
   

      // from the async state object.
   
   

      StateObject state = (StateObject) ar.AsyncState;
   
   

      Socket client = state.workSocket;
   
   

      // Read data from the remote device.
   
   

      int bytesRead = client.EndReceive(ar);
   
   

      if (bytesRead > 0) {
   
   

        // There might be more data, so store the data received so far.
   
   

      state.sb.Append(Encoding.ASCII.GetString(state.buffer,0,bytesRead));
   
   

        //  Get the rest of the data.
   
   

        client.BeginReceive(state.buffer,0,StateObject.BufferSize,0,
   
   

          new AsyncCallback(ReceiveCallback), state);
   
   

      } else {
   
   

        // All the data has arrived; put it in response.
   
   

        if (state.sb.Length > 1) {
   
   

          response = state.sb.ToString();
   
   

        }
   
   

        // Signal that all bytes have been received.
   
   

        receiveDone.Set();
   
   

      }
   
   

    } catch (Exception e) {
   
   

      Console.WriteLine(e.ToString());
   
   

    }
   
   

  }
   
   

  private static void Send(Socket client, String data) {
   
   

    // Convert the string data to byte data using ASCII encoding.
   
   

    byte[] byteData = Encoding.ASCII.GetBytes(data);
   
   

    // Begin sending the data to the remote device.
   
   

    client.BeginSend(byteData, 0, byteData.Length, 0,
   
   

      new AsyncCallback(SendCallback), client);
   
   

  }
   
   

  private static void SendCallback(IAsyncResult ar) {
   
   

    try {
   
   

      // Retrieve the socket from the state object.
   
   

      Socket client = (Socket) ar.AsyncState;
   
   

      // Complete sending the data to the remote device.
   
   

      int bytesSent = client.EndSend(ar);
   
   

      Console.WriteLine("Sent {0} bytes to server.", bytesSent);
   
   

      // Signal that all bytes have been sent.
   
   

      sendDone.Set();
   
   

    } catch (Exception e) {
   
   

      Console.WriteLine(e.ToString());
   
   

    }
   
   

  }
   
   

  public static int Main(String[] args) {
   
   

    StartClient();
   
   

    return 0;
   
   

  }
   
   

}
   
   

异步服务器套接字示例

下面的示例程序创建一个接收来自客户端的连接请求的服务器。该服务器是用异步套接字生成的，因此在等待来自客户端的连接时不挂起服务器应用程序的执行。该应用程序接收来自客户端的字符串，在控制台显示该字符串，然后将该字符串回显到客户端。来自客户端的字符串必须包含字符串“<EOF>”，以发出表示消息结尾的信号。

 [C#]
    
    

using System;
   
   

using System.Net;
   
   

using System.Net.Sockets;
   
   

using System.Text;
   
   

using System.Threading;
   
   

// State object for reading client data asynchronously
   
   

public class StateObject {
   
   

   public Socket workSocket = null;       // Client  socket.
   
   

   public const int BufferSize = 1024;       // Size of receive buffer.
   
   

   public byte[] buffer = new byte[BufferSize]; // Receive buffer.
   
   

   public StringBuilder sb = new StringBuilder();  // Received data string.
   
   

}
   
   

public class AsynchronousSocketListener {
   
   

   // Incoming data from client.
   
   

   public static string data = null;
   
   

   // Thread signal.
   
   

   public static ManualResetEvent allDone = new ManualResetEvent(false);
   
   

   public AsynchronousSocketListener() {
   
   

   }
   
   

   public static void StartListening() {
   
   

      // Data buffer for incoming data.
   
   

      byte[] bytes = new Byte[1024];
   
   

      // Establish the local endpoint for the  socket.
   
   

      //   The DNS name of the computer
   
   

      //  running the listener is "host.contoso.com".
   
   

      IPHostEntry ipHostInfo = Dns.Resolve(Dns.GetHostName());
   
   

      IPAddress ipAddress = ipHostInfo.AddressList[0];
   
   

      IPEndPoint localEndPoint = new IPEndPoint(ipAddress, 11000);
   
   

      // Create a TCP/IP  socket.
   
   

      Socket listener = new Socket(AddressFamily.InterNetwork,
   
   

         SocketType.Stream, ProtocolType.Tcp );
   
   

      // Bind the  socket to the local endpoint and listen for incoming connections.
   
   

      try {
   
   

         listener.Bind(localEndPoint);
   
   

         listener.Listen(100);
   
   

         while (true) {
   
   

            // Set the event to  nonsignaled state.
   
   

            allDone.Reset();
   
   

            // Start  an asynchronous socket to listen for connections.
   
   

            Console.WriteLine("Waiting for a connection...");
   
   

            listener.BeginAccept( 
   
   

               new AsyncCallback(AcceptCallback),
   
   

               listener );
   
   

            // Wait until a connection is made before continuing.
   
   

            allDone.WaitOne();
   
   

         }
   
   

      } catch (Exception e) {
   
   

         Console.WriteLine(e.ToString());
   
   

      }
   
   

      Console.WriteLine("/nHit enter to continue...");
   
   

      Console.Read();
   
   

   }
   
   

   public static void AcceptCallback(IAsyncResult ar) {
   
   

      // Signal the main thread to continue.
   
   

      allDone.Set();
   
   

      // Get the socket that handles the client request.
   
   

      Socket listener = (Socket) ar.AsyncState;
   
   

      Socket handler = listener.EndAccept(ar);
   
   

      // Create the state object.
   
   

      StateObject state = new StateObject();
   
   

      state.workSocket = handler;
   
   

      handler.BeginReceive( state.buffer, 0, StateObject.BufferSize, 0,
   
   

         new AsyncCallback(ReadCallback), state);
   
   

   }
   
   

   public static void ReadCallback(IAsyncResult ar) {
   
   

      String content = String.Empty;
   
   

      // Retrieve the state object and the handler socket
   
   

      // from the async state object.
   
   

      StateObject state = (StateObject) ar.AsyncState;
   
   

      Socket handler = state.workSocket;
   
   

      // Read data from the client socket. 
   
   

      int bytesRead = handler.EndReceive(ar);
   
   

      if (bytesRead > 0) {
   
   

         // There  might be more data, so store  the data received so far.
   
   

         state.sb.Append(Encoding.ASCII.GetString(
   
   

            state.buffer,0,bytesRead));
   
   

         // Check for end-of-file tag. If  it is not there, read 
   
   

         // more data.
   
   

         content = state.sb.ToString();
   
   

         if (content.IndexOf("<EOF>") > -1) {
   
   

            // All the data has been read from the 
   
   

            // client. Display it on the console.
   
   

            Console.WriteLine("Read {0} bytes from socket. /n Data : {1}",
   
   

               content.Length, content );
   
   

            // Echo the data back to the client.
   
   

            Send(handler, content);
   
   

         } else {
   
   

            // Not all data received. Get more.
   
   

            handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,
   
   

            new AsyncCallback(ReadCallback), state);
   
   

         }
   
   

      }
   
   

   }
   
   

   private static void Send(Socket handler, String data) {
   
   

      // Convert the string data to byte data using ASCII encoding.
   
   

      byte[] byteData = Encoding.ASCII.GetBytes(data);
   
   

      // Begin sending the data to the remote device.
   
   

      handler.BeginSend(byteData, 0, byteData.Length, 0,
   
   

         new AsyncCallback(SendCallback), handler);
   
   

   }
   
   

   private static void SendCallback(IAsyncResult ar) {
   
   

      try {
   
   

         // Retrieve the socket from the state object.
   
   

         Socket handler = (Socket) ar.AsyncState;
   
   

         // Complete sending the data to the remote device.
   
   

         int bytesSent = handler.EndSend(ar);
   
   

         Console.WriteLine("Sent {0} bytes to client.", bytesSent);
   
   

         handler.Shutdown(SocketShutdown.Both);
   
   

         handler.Close();
   
   

      } catch (Exception e) {
   
   

         Console.WriteLine(e.ToString());
   
   

      }
   
   

   }
   
   

   public static int Main(String[] args) {
   
   

      StartListening();
   
   

      return 0;
   
   

   }
   
   

}
   
   

使用 Net 类的最佳做法

下列建议将帮助您最有效地使用 System.Net 中包含的类：

• 尽可能使用 WebRequest 和 WebResponse 而不是类型转换为子代类。使用 WebRequest 和 WebResponse 的应用程序可以利用新的 Internet 协议，而不需要进行大范围的代码更改。
• 当使用 System.Net 类编写运行在服务器上的 ASP.NET 应用程序时，从性能的角度来看，使用 GetResponse 和 GetResponseStream 的异步方法通常更好。
• 对 Internet 资源打开的连接数可能对网络性能和吞吐量有显著的影响。默认情况下，System.Net 对每个主机的每个应用程序使用两个连接。设置应用程序的 ServicePoint 中的 ConnectionLimit 属性可为特定主机增加此数目。设置 ServicePointManager.DefaultPersistentConnectionLimit 属性可为所有主机增加此默认值。
• 当编写套接字级别的协议时，请尽可能尝试使用 TCPClient 或 UDPClient，而不是直接向 Socket 中写。这两个客户端类封装 TCP 和 UDP 套接字的创建，而不需要您处理连接的细节。
• 当访问要求凭据的站点时，请使用 CredentialCache 类创建凭据的缓存而不要对每个请求都提供它们。CredentialCache 类搜索缓存以查找要提供给请求的适当凭据，从而使您不必根据统一资源定位器来创建和提供凭据。

总结

    上面是VS.NET中.NET访问Internet的一些基本概念和代码示例（包括访问Internet的各种方法和步骤），给大家参考一下。有任何建议请MAIL我 paulni@citiz.net。