根据如下代码该如何写HTTP服务端及客户端？

Question

using System.Collections;
using System.Net;
using System.Net.Sockets;
using System.Threading;namespace SocketServer
{
  public interface SocketService
  {
    void Serve(Socket s);
  }  public class SocketServer
  {
    private TcpListener serverSocket = null;
    private Thread serverThread = null;
    private bool running = false;
    private SocketService itsService = null;
    private ArrayList threads = new ArrayList();    public SocketServer(int port, SocketService service)
    {
      itsService = service;
      IPAddress addr = IPAddress.Parse("127.0.0.1");
      serverSocket = new TcpListener(addr, port);
      serverSocket.Start();
      serverThread = new Thread(new ThreadStart(Server));
      serverThread.Start();
    }    public void Close()
    {
      running = false;
      serverThread.Interrupt();
      serverSocket.Stop();
      serverThread.Join();
      WaitForServiceThreads();
    }    private void Server()
    {
      running = true;
      while (running)
      {
        Socket s = serverSocket.AcceptSocket();
        StartServiceThread(s);
      }
    }    private void StartServiceThread(Socket s)
    {
      Thread serviceThread =
        new Thread(new ServiceRunner(s, this).ThreadStart());
      lock (threads)
      {
        threads.Add(serviceThread);
      }
      serviceThread.Start();
    }    private void WaitForServiceThreads()
    {
      while (threads.Count > 0)
      {
        Thread t;
        lock (threads)
        {
          t = (Thread) threads[0];
        }        t.Join();
      }
    }    internal class ServiceRunner
    {
      private Socket itsSocket;
      private SocketServer itsServer;      public ServiceRunner(Socket s, SocketServer server)
      {
        itsSocket = s;
        itsServer = server;
      }
      public void Run()
      {
        itsServer.itsService.Serve(itsSocket);
        lock (itsServer.threads)
        {
          itsServer.threads.Remove(Thread.CurrentThread);
        }
        itsSocket.Close();
      }      public ThreadStart ThreadStart()
      {
        return new ThreadStart(Run);
      }
    }
  }
}C#控制台应用程序，服务器端能监听连入多台机子的IP就好，
客户端就随便显示一个WELCOME就好。

Answer 1

客户端直接SOCKET连接就好了呀但是服务端必须建立一个HASHTABLE来保存每一个连接信息.

Answer 2

使用异步socket和委托实现的Server,代码简单using System;
using System.Collections.Generic;
using System.Text;
using System.Net;
using System.Net.Sockets;namespace MessagerQServer
{
    internal class AppServer
    {
        private byte[] msgBuff = new byte[1024]; // Receive data buffer        private Socket serverSock = null;
        internal delegate void NewConnectionEventHandler(Socket sock);
        internal event NewConnectionEventHandler OnNewConnect;        internal Socket ServerSocket
        {
            get
            {
                return this.serverSock;
            }
        }        internal void Start(int port)
        {
            serverSock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            serverSock.Bind(new IPEndPoint(IPAddress.Loopback, port)); // For use with localhost 127.0.0.1
            serverSock.Listen(10);            // Setup a callback to be notified of connection requests
            serverSock.BeginAccept(new AsyncCallback(OnConnectRequest), serverSock);
        }        private void OnConnectRequest(IAsyncResult ar)
        {
            try
            {
                Socket listener = (Socket)ar.AsyncState;
                NewConnection(listener.EndAccept(ar));
                listener.BeginAccept(new AsyncCallback(OnConnectRequest), listener);
            }
            catch (Exception ex)
            {
                Console.WriteLine("Connected callback setup failed! {0}", ex.Message);
            }
        }        private void NewConnection(Socket clientSock)
        {
            // Program blocks on Accept() until a client connects.
            // SocketChatClient client = new SocketChatClient( listener.AcceptSocket() );
            // SocketChatClient client = new SocketChatClient(sockClient);
            // m_aryClients.Add(client);
            Console.WriteLine("Client {0}, joined", clientSock.RemoteEndPoint);
            if (OnNewConnect != null) OnNewConnect(clientSock);                   String connectedMsg = "Connected to " + clientSock.LocalEndPoint + "成功 \n\r";
            // Convert to byte array and send.
            Byte[] byteMsg = System.Text.Encoding.Unicode.GetBytes(connectedMsg.ToCharArray());
            clientSock.Send(byteMsg, byteMsg.Length, 0);            SetupRecieveCallback(clientSock);
        }        private void SetupRecieveCallback(Socket sock)
        {
            try
            {
                AsyncCallback recieveData = new AsyncCallback(OnRecievedData);
                sock.BeginReceive(msgBuff, 0, msgBuff.Length, SocketFlags.None, recieveData, sock);
            }
            catch (Exception ex)
            {
                Console.WriteLine("Recieve callback setup failed! {0}", ex.Message);
            }
        }        private void OnRecievedData(IAsyncResult ar)
        {
            Socket sock = (Socket)ar.AsyncState;
            // Check if we got any data
            try
            {
                int nBytesRec = sock.EndReceive(ar);
                if (nBytesRec > 0)
                {
                    // Get the received message 
                    string sRecieved = Encoding.Unicode.GetString(msgBuff, 0, nBytesRec);
                    // Process it
                    ProcessMessage(sock, sRecieved);                    SetupRecieveCallback(sock);
                }
                else
                {
                    // If no data was recieved then the connection is probably dead
                    Console.WriteLine("disconnect from server {0}", sock.RemoteEndPoint);
                    sock.Shutdown(SocketShutdown.Both);
                    sock.Close();
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message, "Unusual error druing Recieve!");
            }
        }        private void ProcessMessage(Socket sock, string msg)
        {
            Byte[] byteAnswer = System.Text.Encoding.Unicode.GetBytes(msg.ToCharArray());
            sock.Send(byteAnswer);           
        }        internal void Close()
        {
            if (serverSock != null)
            {
                if (serverSock.Connected) serverSock.Shutdown(SocketShutdown.Both);
                serverSock.Close();
            }
        }
        internal void disConnect()
        {
            if (serverSock != null)
            {
                if(serverSock.Connected) serverSock.Disconnect(true);
            }
        }
        internal void Start()
        {
            int port = 8000;
            serverSock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            serverSock.Bind(new IPEndPoint(IPAddress.Loopback, port)); // For use with localhost 127.0.0.1
            serverSock.Listen(10);            // Setup a callback to be notified of connection requests
            serverSock.BeginAccept(new AsyncCallback(OnConnectRequest), serverSock);
        }
    }
}