예제 #1
0
        private void AsyncReadDone(IAsyncResult ar)
        {
            lock (_socketLocker)
            {
                try
                {
                    var buff = (byte[])ar.AsyncState;
                    if (buff == null)
                    {
                        return;
                    }
                    if (Sock.Client == null)
                    {
                        return;
                    }
                    int rin = Sock.Client.EndReceive(ar);
                    if (rin > 0)
                    {
                        if (rin != 256)
                        {
                            Array.Resize(ref buff, rin);
                        }
                        _builder.AddBytes(buff);
                    }
                    else
                    {
                        LazyAsync.Invoke(Stop);
                    }
                }
                catch (SocketException se)
                {
                    #region "SocketErrors"

                    switch (se.SocketErrorCode)
                    {
                    case SocketError.ConnectionAborted:
                    {
                        LazyAsync.Invoke(Stop);
                        break;
                    }

                    case SocketError.ConnectionReset:
                    {
                        LazyAsync.Invoke(Stop);
                        break;
                    }

                    case SocketError.Disconnecting:
                    {
                        LazyAsync.Invoke(Stop);
                        break;
                    }

                    case SocketError.NetworkDown:
                    {
                        LazyAsync.Invoke(Stop);
                        break;
                    }

                    case SocketError.NetworkReset:
                    {
                        LazyAsync.Invoke(Stop);
                        break;
                    }

                    case SocketError.NoRecovery:
                    {
                        LazyAsync.Invoke(Stop);
                        break;
                    }

                    case SocketError.NotConnected:
                    {
                        LazyAsync.Invoke(Stop);
                        break;
                    }

                    case SocketError.OperationAborted:
                    {
                        LazyAsync.Invoke(Stop);
                        break;
                    }

                    case SocketError.Shutdown:
                    {
                        LazyAsync.Invoke(Stop);
                        break;
                    }

                    case SocketError.SocketError:
                    {
                        LazyAsync.Invoke(Stop);
                        break;
                    }

                    case SocketError.TimedOut:
                    {
                        break;
                    }

                    default:
                    {
                        Trace.WriteLine("ss2:" + se.Message);
                        Trace.WriteLine(se.StackTrace);
                        break;
                    }
                    }

                    #endregion
                }
                catch (ObjectDisposedException oe)
                {
                    Trace.WriteLine("ss5:" + oe.Message);
                    Trace.WriteLine(oe.StackTrace);
                }
                catch (NullReferenceException ne)
                {
                    Trace.WriteLine("ss3:" + ne.Message);
                    Trace.WriteLine(ne.StackTrace);
                }
                catch (Exception e)
                {
                    Trace.WriteLine("ss4:" + e.Message);
                    Trace.WriteLine(e.StackTrace);
                }
                while (_builder.SmQueue.Count > 0)
                {
                    SocketMessage sm = _builder.SmQueue.Dequeue();
                    if (sm == null)
                    {
                        continue;
                    }
                    if (OnMessageReceived != null)
                    {
                        OnMessageReceived.BeginInvoke(this, (SocketMessage)sm.Clone(), null, null);
                    }
                }
                LazyAsync.Invoke(AsyncRead);
            }
        }