异步Socket的BeginReceive()方法里AsyncCallback方法里面为什么还要重新写BeginReceive()?

Question

异步Socket的BeginReceive()方法里AsyncCallback方法里面为什么还要重新写BeginReceive()?
异步Socket的BeginAccpet()方法里AsyncCallback方法里面为什么还要重新写BeginAccpet()?
那BeginConnect()和BeginSend()是否有必要也得这么写?
请熟悉.net网络编程的GGMM告诉小弟下？
示例代码如下：        public virtual void Start()
        {
            if (_isRun)
            {
                throw (new ApplicationException("TcpSvr已经在运行."));
            }
            _sessionTable = new Hashtable(1024);
            _recvDataBuffer = new byte[DefaultBufferSize];
            _svrSock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);            IPEndPoint iep = new IPEndPoint(IPAddress.Any, _port);
            _svrSock.Bind(iep);
            _svrSock.Listen(1024);
            _svrSock.BeginAccept(new AsyncCallback(AcceptConn), _svrSock);            _isRun = true;
        }        protected virtual void AcceptConn(IAsyncResult iar)
        {
            //如果服务器停止了服务,就不能再接收新的客户端
            if (!_isRun)
            {
                return;
            }            //接受一个客户端的连接请求
            Socket oldserver = (Socket)iar.AsyncState;
            Socket client = oldserver.EndAccept(iar);            //检查是否达到最大的允许的客户端数目
            if (_clientCount == _maxClient)
            {
                if (ServerFull != null)
                {
                    ServerFull(this, new NetEventArgs(new Session(client)));
                }
            }
            else
            {
                //新建一个客户端连接
                Session newSession = new Session(client);
                _sessionTable.Add(newSession.ID, newSession);                _clientCount++;                newSession.RecvDataBuffer = new byte[16 * 1024];
                //开始接受来自该客户端的数据
                client.BeginReceive(newSession.RecvDataBuffer, 0, newSession.RecvDataBuffer.Length, SocketFlags.None,
                 new AsyncCallback(ReceiveData), newSession);                //新的客户段连接,发出通知
                if (ClientConn != null)
                {
                    ClientConn(this, new NetEventArgs(newSession));
                }
            }            //继续接受客户端
            _svrSock.BeginAccept(new AsyncCallback(AcceptConn), _svrSock);
        }        protected virtual void ReceiveData(IAsyncResult iar)
        {
            Session sendDataSession = (Session)iar.AsyncState;
            Socket client = sendDataSession.ClientSocket;            try
            {
                //如果两次开始了异步的接收,所以当客户端退出的时候
                //会两次执行EndReceive
                int recv = client.EndReceive(iar);                if (recv == 0)
                {
                    CloseClient(client, Session.ExitType.NormalExit);
                    return;
                }                string receivedData = _coder.GetEncodingString(sendDataSession.RecvDataBuffer, recv);
                //string receivedData = _coder.GetEncodingString(_recvDataBuffer, recv);                //发布收到数据的事件
                if (RecvData != null)
                {
                    //Session sendDataSession = FindSession(client);                    Debug.Assert(sendDataSession != null);                    if (_resolver != null)
                    {
                        if (sendDataSession.Datagram != null && sendDataSession.Datagram.Length != 0)
                        {
                            receivedData = sendDataSession.Datagram + receivedData;
                        }                        string[] recvDatagrams = _resolver.Resolve(ref receivedData);                        foreach (string newDatagram in recvDatagrams)
                        {
                            ICloneable copySession = (ICloneable)sendDataSession;
                            Session clientSession = (Session)copySession.Clone();                            string strDatagram = newDatagram;
                            //clientSession.ClassName = this.GetClassFullName(ref strDatagram);
                            clientSession.Datagram = strDatagram;                            //发布一个报文消息
                            RecvData(this, new NetEventArgs(clientSession));
                        }                        //剩余的代码片断,下次接收的时候使用
                        sendDataSession.Datagram = receivedData;                        if (sendDataSession.Datagram.Length > MaxDatagramSize)
                        {
                            sendDataSession.Datagram = null;
                        }
                    }
                    else
                    {
                        ICloneable copySession = (ICloneable)sendDataSession;
                        Session clientSession = (Session)copySession.Clone();
                        //clientSession.ClassName = this.GetClassFullName(ref receivedData);
                        clientSession.Datagram = receivedData;                        RecvData(this, new NetEventArgs(clientSession));
                    }
                }                //继续接收来自来客户端的数据
                client.BeginReceive(sendDataSession.RecvDataBuffer, 0, sendDataSession.RecvDataBuffer.Length, SocketFlags.None,
                 new AsyncCallback(ReceiveData), sendDataSession);
            }
            catch (SocketException ex)
            {
                if (10054 == ex.ErrorCode)
                {
                    //客户端强制关闭
                    CloseClient(client, Session.ExitType.ExceptionExit);
                }            }
            catch (ObjectDisposedException ex)
            {
                if (ex != null)
                {
                    ex = null;
                    //DoNothing;
                }
            }
        }

Answer 1

你是看不懂注释还是怎么的，你那注释写的很清楚了，是继续接收。
一个服务器端总不可能只允许一个用户连进来吧，不重新写BeginAccpet()，那其他用户连怎么连进来？
数据接收总不可能一次性接收完毕吧，一个数据包大小有限，最多就1千多个字节，不重新写BeginReceive(),那后续的数据不要接收了吗？

Answer 2

你想做一锤子买卖就不必继续Receive了...