socket.BeginRecive()问题

Question

本帖最后由 ZSW53362465 于 2010-04-09 15:40:58 编辑

Answer 1

这两个函数应该是一个自己的Sockect派生类中的函数吧。至少我是这么用的。

Answer 2

感觉也是有问题若是有多个用户都在发送数据，那么这个Buffer就完了处理方式一般是一个连接给一个Buffer，
不过你的 AsyncConnect（IAsyncResult aResult）方法 处理完连接回调后，没有再进行监听。没实现递归调用了。

Answer 3

我觉得6楼有道理
这个部分程序是服务器对单客户机的，如果是多客户机，应该是个死循环，不断地accept（）
这时候最好把数组和socket封装在一个类中，传递给异步调用函数，这样endreceive既可以得到socket，又可以得到缓冲数组，又因为它不是全局的，所有不用担心重用问题

Answer 4

还 connect ？如果你是抄的别人服务器代码，你上当了。

Answer 5

既然你“看过很多的例子”，贴出一个最贴近你的代码的，我们来看看人家的demo跟你的代码区别。

Answer 6

如果全局的这个对象不是静态的,同时不被多个线程访问,那么他可以说是安全的.如果使用异步调用要改写这个属性的话,建议使用lock 这并非最好的解决办法,但是是最简单的.

Answer 7

我看你这个类没有任何问题, 首先,里面没有实现循环监听,所以只可能有1个通信,不会出现线程同时操作对象的可能.除非在类的外部,有2个或者以上的线程可以操作<这个类的同一个实例>,否则也不会出现问题.

Answer 8

 private void AsyncConnect(IAsyncResult aResult)
//不好意思，在这个函数里面的Catch上边还有一段代码  没有写进去
if (IsStopServer == false)//如果没有终止侦听，则继续异步接收新连接请求
                 {
                        sock.BeginAccept(new AsyncCallback(AsyncAcceptSocket), sock);
                    }

Answer 9

在重新发一遍吧        //全局默认缓冲
        byte[] DefaultBuffer=new byte[4*1024];
        /// <summary>
        /// 异步联接
        /// </summary>
        /// <param name="aResult"></param>
        private void AsyncConnect(IAsyncResult aResult)
        {
            System.Net.Sockets.Socket sock = (System.Net.Sockets.Socket)aResult.AsyncState;
            try
            {
                sock.EndConnect(aResult);                if (sock != null && sock.Connected)
                {
                    if (OnConnected != null)
                        OnConnected(this, null);//触发连接建立事件                    
                    if (IsStopServer == false)
                    {
                        sock.BeginReceive(DefaultBuffer, 0, DefaultBuffer.Length, System.Net.Sockets.SocketFlags.None, new AsyncCallback(AsyncDataReceive), sock);（相当于给DefaultBuffer赋值）
                    }
if (IsStopServer == false)//如果没有终止侦听，则继续异步接收新连接请求
                 {
                        sock.BeginAccept(new AsyncCallback(AsyncAcceptSocket), sock);
                    }
                }            }
            catch (Exception ex)
            {
                if (OnError != null)
                    OnError(this, new IMLibrary.Net.SockEventArgs(4, ex.Message));
            }
        }        /// <summary>
        /// 异步接收数据
        /// </summary>
        /// <param name="aResult">IAsyncResult接口对象</param>
        private void AsyncDataReceive(IAsyncResult aResult)
        {
            Socket sock= (Socket)aResult.AsyncState;
            try
            {
                if (IsStopServer == false)
                {
                    int iReceiveCount = sock.EndReceive(aResult);
                    if (iReceiveCount > 0)
                    {                         
                        //使用DefaultBuffer 例如:
                      string reciveStr = Encording.UTF-8.GetString(DefaultBuffer);//使用全局DefaultBuffer
                           
                        if ( IsStopServer == false)
                        {
                            sock.BeginReceive(DefaultBuffer,0, myTcp.Buffer.Length, System.Net.Sockets.SocketFlags.None, new AsyncCallback(AsyncDataReceive), myTcp);
                        }
                    }
                    else
                    {
                        Disconnect();
                    }
                }
             
            }
            catch (Exception ex)
            {
                if (OnError != null)
                    OnError(this, ex.ToString());
            }
        }

Answer 10

 //全局默认缓冲
        byte[] DefaultBuffer=new byte[4*1024];
        /// <summary>
        /// 异步联接
        /// </summary>
        /// <param name="aResult"></param>
        private void AsyncConnect(IAsyncResult aResult)
        {
            System.Net.Sockets.Socket sock = (System.Net.Sockets.Socket)aResult.AsyncState;
            try
            {
                sock.EndConnect(aResult);                if (sock != null && sock.Connected)
                {
                    if (OnConnected != null)
                        OnConnected(this, null);//触发连接建立事件                    
                    if (IsStopServer == false)
                    {
                        sock.BeginReceive(DefaultBuffer, 0, DefaultBuffer.Length, System.Net.Sockets.SocketFlags.None, new AsyncCallback(AsyncDataReceive), sock);（相当于给DefaultBuffer赋值）
                    }
if (IsStopServer == false)//如果没有终止侦听，则继续异步接收新连接请求
                 {
                        sock.BeginAccept(new AsyncCallback(AsyncAcceptSocket), sock);
                    }
                }            }
            catch (Exception ex)
            {
                if (OnError != null)
                    OnError(this, new IMLibrary.Net.SockEventArgs(4, ex.Message));
            }
        }        /// <summary>
        /// 异步接收数据
        /// </summary>
        /// <param name="aResult">IAsyncResult接口对象</param>
        private void AsyncDataReceive(IAsyncResult aResult)
        {
            Socket sock= (Socket)aResult.AsyncState;
            try
            {
                if (IsStopServer == false)
                {
                    int iReceiveCount = sock.EndReceive(aResult);
                    if (iReceiveCount > 0)
                    {                         
                        //使用DefaultBuffer 例如:
                      string reciveStr = Encording.UTF-8.GetString(DefaultBuffer);//使用全局DefaultBuffer
                           
                        if ( IsStopServer == false)
                        {
                            sock.BeginReceive(DefaultBuffer,0, DefaultBuffer.Length, System.Net.Sockets.SocketFlags.None, new AsyncCallback(AsyncDataReceive), myTcp);
                        }
                    }
                    else
                    {
                        Disconnect();
                    }
                }
             
            }
            catch (Exception ex)
            {
                if (OnError != null)
                    OnError(this, ex.ToString());
            }
        }