异步服务器套接字示例
下面的示例程序创建一个接收来自客户端的连接请求的服务器。该服务器是用异步套接字生成的，因此在等待来自客户端的连接时不挂起服务器应用程序的执行。该应用程序接收来自客户端的字符串，在控制台显示该字符串，然后将该字符串回显到客户端。来自客户端的字符串必须包含字符串“<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(paulni@citiz