使用.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我 [email protected]。

本文地址：http://com.8s8s.com/it/it46075.htm