CSDN博客

img Paul_Ni

使用.NET访问Internet(5)

发表于2002/4/18 9:25:00  825人阅读

同步客户端套接字示例

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

 [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 而不是类型转换为子代类。使用 WebRequestWebResponse 的应用程序可以利用新的 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

 

0 0

相关博文

我的热门文章

img
取 消
img