Server代碼
using System;
using System.IO;
using System.Collections.Generic;
using System.Text;
using System.Net;
using System.Net.Sockets;


namespace SocketSvr
{
    class Program
    {
        private static byte[] msgBuff = new byte[10240];    
        //private static Socket clientSocket;
        const int nListenPort = 8888;
       

        static void Main(string[] args)
        {
            Socket Listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream,
                ProtocolType.Tcp);

            IPHostEntry myIpHostEntry = Dns.GetHostEntry("sitd-RogerWang");
            IPEndPoint myIpEndPoint = new IPEndPoint(myIpHostEntry.AddressList[0],nListenPort);
            Listener.Bind(myIpEndPoint);

            Listener.Listen(10);
            Console.WriteLine("Server Listen Start..");
            Listener.BeginAccept(new AsyncCallback(OnConnectRequest), Listener);

            Console.ReadLine();            
        }

        public static void OnConnectRequest(IAsyncResult ar)
        {
            
            Socket Listener = (Socket)ar.AsyncState;
            NewConnection(Listener.EndAccept(ar));            
            Listener.BeginAccept(new AsyncCallback(OnConnectRequest), Listener);
        }

        public static void NewConnection(Socket clientSocket)
        {
            Console.WriteLine("Client {0},Joined..", clientSocket.RemoteEndPoint);

            string connectedMsg = "Connected to " + clientSocket.LocalEndPoint + " success \n\r";
            byte[] byteMsg = System.Text.Encoding.ASCII.GetBytes(connectedMsg.ToCharArray());
            clientSocket.Send(byteMsg, byteMsg.Length, 0);

            SetupRecieveCallback(clientSocket);
        }

        //定義服務器端如何接受從客戶端取得數據
        public static 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);
            }
        }


        public static 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.ASCII.GetString(msgBuff, 0, nBytesRec);
                    Console.WriteLine("Receive Data is {0}", sRecieved);

                    ProcessMessage(sock, sRecieved.ToUpper());
                    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!");
            }
        }

        public static void ProcessMessage(Socket sock, string msg)
        {
            
            int count = msg.Length;
            if (count > 0)
            {
                Console.WriteLine("Send Data is {0}", msg);
                sock.Send(System.Text.Encoding.ASCII.GetBytes(msg.ToCharArray()));
            }
        }

    }
}



Client代碼:
using System;
using System.Collections.Generic;
using System.Text;
using System.Windows.Forms;
using System.Threading;
using System.IO;
using System.Net;
using System.Net.Sockets;

namespace SocketClient
{
    class  ClientObj
    {
        private static  byte[] msgBuff = new byte[10240];
        private static  Socket clientSocket;
        private ListViewItem m_lvItem;

        private int m_ClientUpdateInterval;
        private int m_ClientUpdateMessages;
        
        private string m_message;
        private string m_ReturnMsg;


        public ClientObj(ListViewItem lvItem, int updateInterval, int updateMessages, string strMessage)
        {
           // m_ClientModelData = model;
            m_lvItem = lvItem;
            m_ClientUpdateInterval = updateInterval;
            m_ClientUpdateMessages = updateMessages;
            
            m_message = strMessage;            
        }

        public void SendMsg(string sendMsg)
        {
            Byte[] byteMsg = System.Text.Encoding.ASCII.GetBytes(sendMsg.ToCharArray());
            if (clientSocket != null)
            {
                if (clientSocket.Connected)
                {
                    clientSocket.Send(byteMsg);
                }
            } 
        }

        public void Connect()
        {
            try
            {

                clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream,
                    ProtocolType.Tcp);
                IPHostEntry myIpHostEntry = Dns.GetHostEntry("sitd-RogerWang");
                IPEndPoint epServer = new IPEndPoint(myIpHostEntry.AddressList[0], 8888);

                clientSocket.Blocking = false;
                clientSocket.BeginConnect(epServer, new AsyncCallback(OnConnect), clientSocket);
            }
            catch (Exception e)
            {
                Console.WriteLine("Connected To Server failed");
                Console.WriteLine(e.Message);
            }
        }

        public 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);
            }
        }

        public void OnConnect(IAsyncResult ar)
        {
            Socket sock = (Socket)ar.AsyncState;

            try
            {
                if (sock.Connected)
                {
                    SetupRecieveCallback(sock);
                }
                else
                {
                    Console.WriteLine("Unable to connect to remote machine", "Connect Failed!");
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message, "Unusual error during Connect!");
            }
        }

        public 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.ASCII.GetString(msgBuff, 0, nBytesRec);

                    m_ReturnMsg = sRecieved;
                    // Process it
                    //ProcessMessage(sock, sRecieved);
                    //lbMessage.Items.Add(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!");
            }
        }

        public void StartSimulate()
        {
            DateTime dtBegin = DateTime.Now;
            DateTime dtEnd = DateTime.Now;
            int MessagesCount = 0;
            int TimeUsedCount = 0;
            int timeUsedHigh = 0;
            int timeUsedLow = int.MaxValue;
            long iTimeCount = 0;
            float fTimeCount = 0;
            string strReturnMessage = string.Empty;

            Connect();

            lock (m_lvItem)
            {
                m_lvItem.SubItems[1].Text = dtBegin.ToString();
            }

            while (Program.isRunning)
            {
                dtBegin = DateTime.Now;
                try
                {
                    for (int i = 0; i < m_ClientUpdateMessages; i++)
                    {
                        //strReturnMessage = m_RemotingObj.HelloTheWorldEcho(m_message);
                    }
                }
                catch (Exception ex)
                {
                    
                }

                dtEnd = DateTime.Now;
                //iTimeCount = iTimeCount + (dtEnd.Ticks - dtBegin.Ticks);
                iTimeCount = (dtEnd.Ticks - dtBegin.Ticks);
                fTimeCount = iTimeCount / 10000;    //等弇岆瑭鏃

                MessagesCount++;
                TimeUsedCount += (int)fTimeCount;
                if (timeUsedHigh < fTimeCount)
                {
                    timeUsedHigh = (int)fTimeCount;
                }
                if (timeUsedLow > fTimeCount)
                {
                    timeUsedLow = (int)fTimeCount;
                }


                SendMsg(m_message);

                lock (m_lvItem)
                {
                    try
                    {
                        m_lvItem.SubItems[2].Text = dtEnd.ToString();   //郔綴奻換奀潔
                        m_lvItem.SubItems[3].Text = m_ClientUpdateMessages.ToString(); //奻換杅擂杅
                        m_lvItem.SubItems[4].Text = fTimeCount.ToString(); //郔綴奻換瑭奀
                        m_lvItem.SubItems[5].Text = timeUsedHigh.ToString(); //奻換詢瑕
                        m_lvItem.SubItems[6].Text = timeUsedLow.ToString(); //奻換腴瑕

                        m_lvItem.SubItems[7].Text = MessagesCount.ToString(); //奻換杅擂軞杅
                        m_lvItem.SubItems[8].Text = TimeUsedCount.ToString(); //奻換軞瑭奀
                        m_lvItem.SubItems[9].Text = m_ReturnMsg; //殿隙秏洘
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine(ex.Message);
                    }
                }
                if (fTimeCount < m_ClientUpdateInterval * 1000)
                {
                    Thread.Sleep((int)(m_ClientUpdateInterval * 1000 - fTimeCount));
                }
            }
        }
    }
}