Пример #1
0
 /// <summary>
 /// 开始异步接收,同时处理传入的事件参数,里面可能有接收到的数据
 /// </summary>
 /// <param name="e"></param>
 internal new void ReceiveAsync(NetEventArgs e)
 {
     if (e.BytesTransferred > 0)
         OnReceive(e);
     else
         base.ReceiveAsync(e);
 }
Пример #2
0
        /// <summary>子类重载实现资源释放逻辑</summary>
        /// <param name="disposing">从Dispose调用(释放所有资源)还是析构函数调用(释放非托管资源)</param>
        protected override void OnDispose(bool disposing)
        {
            base.OnDispose(disposing);

            //  if (_arg != null) NetEventArgs.Push(_arg); //此处不能做此操作,会导致异常,并且连接无法正常断开,移动把网络清理干净后,再将参数还回池中

            var socket = Socket;

            if (socket != null)
            {
                //NetHelper.Close(socket, ReuseAddress);
                // 此时Socket可能已经销毁,不能进行Socket操作
                NetHelper.Close(socket, _ReuseAddress);
                Socket = null;
            }

            if (_Statistics != null)
            {
                var dp = _Statistics as IDisposable;
                if (dp != null)
                {
                    dp.Dispose();
                }
                _Statistics = null;
            }
            if (_arg != null)
            {
                NetEventArgs.Push(_arg);
            }
        }
Пример #3
0
        /// <summary>
        /// 已重载。设置RemoteEndPoint
        /// </summary>
        /// <param name="e"></param>
        protected override void OnComplete(NetEventArgs e)
        {
            IPEndPoint ep = e.RemoteEndPoint as IPEndPoint;
            if (ep == null || (ep.Address == IPAddress.Loopback && ep.Port == 0)) e.RemoteEndPoint = RemoteEndPoint;

            base.OnComplete(e);
        }
Пример #4
0
        /// <summary>处理异步结果。</summary>
        /// <param name="e">事件参数</param>
        /// <param name="start">开始新异步操作的委托</param>
        /// <param name="process">处理结果的委托</param>
        protected virtual void Process(NetEventArgs e, Func start, Action <NetEventArgs> process)
        {
            // Socket错误由各个处理器来处理
            if (e.SocketError != SocketError.Success)
            {
                OnError(e, null);
                return;
            }

            try
            {
                // 业务处理的任何异常,都将引发Error事件,但不会影响重新建立新的异步操作
                process(e);
            }
            catch (Exception ex)
            {
                try
                {
                    OnError(e, ex);
                }
                catch { }

                return;
            }

            // 如果不是操作取消,在处理业务完成后再开始异步操作
            if (!Disposed)
            {
                start();
            }
        }
Пример #5
0
 /// <summary>
 /// 已重载。
 /// </summary>
 /// <param name="sender"></param>
 /// <param name="e"></param>
 protected override void OnReceived(object sender, NetEventArgs e)
 {
     if (e.BytesTransferred > 100)
         WriteLog("Chargen {0} [{1}]", e.RemoteEndPoint, e.BytesTransferred);
     else
         WriteLog("Chargen {0} [{1}] {2}", e.RemoteEndPoint, e.BytesTransferred, e.GetString());
 }
Пример #6
0
        void ShowEvent(NetEventArgs e)
        {
            //WriteLog("Completed[{4}] {0} {1} {2} [{3}]", this, e.LastOperation, e.SocketError, e.BytesTransferred, e.ID);
            var sb = new StringBuilder();

            sb.AppendFormat("[{0}] {1} {2}://{3}", e.ID, e.LastOperation, ProtocolType, LocalEndPoint);
            var ep = e.RemoteIPEndPoint;

            //if (ep == null || ep.Address.IsAny()) ep = RemoteEndPoint;
            if ((ep == null || ep.Address.IsAny()) && e.LastOperation == SocketAsyncOperation.Accept && e.AcceptSocket != null)
            {
                ep = e.AcceptSocket.RemoteEndPoint as IPEndPoint;
            }
            if (ep != null && !ep.Address.IsAny())
            {
                sb.AppendFormat("=>{0}", ep);
            }
            //sb.AppendFormat(" {0}", e.LastOperation);
            if (e.SocketError != SocketError.Success)
            {
                sb.AppendFormat(" {0}", e.SocketError);
            }
            sb.AppendFormat(" [{0}]", e.BytesTransferred);
            WriteLog(sb.ToString());
        }
Пример #7
0
        static void CheckNet21()
        {
            var e = new NetEventArgs();

            //(e as IDisposable).Dispose();
            e.AcceptSocket = null;
        }
Пример #8
0
        /// <summary>触发完成事件。如果是异步返回,则在IO线程池中执行;如果是同步返回,则在用户线程池中执行。
        /// 可能由工作线程(事件触发)调用,也可能由用户线程通过线程池线程调用。
        /// 作为顶级,将会处理所有异常并调用OnError,其中OnError有能力回收参数e。
        /// </summary>
        /// <param name="e"></param>
        void RaiseComplete(NetEventArgs e)
        {
            // 异步完成,减少一个计数
            Interlocked.Decrement(ref _AsyncCount);

            if (ShowEventLog && Log.Level >= LogLevel.Debug)
            {
                ShowEvent(e);
            }

            try
            {
                // 这里直接处理操作取消
                if (e.SocketError != SocketError.OperationAborted)
                {
                    OnComplete(e);
                }
                else
                {
                    OnError(e, null);
                }
            }
            catch (Exception ex)
            {
                // 都是在线程池线程里面了,不要往外抛出异常
                OnError(e, ex);
            }
        }
Пример #9
0
        void server_Accepted(object sender, NetEventArgs e)
        {
            TcpClientX session = e.UserToken as TcpClientX;
            if (session == null) return;

            //session.NoDelay = false;
            SetEvent(session);
        }
Пример #10
0
 internal protected void CheckBufferSize(NetEventArgs e)
 {
     //Int32 n = e.BytesTransferred;
     //if (n >= e.Buffer.Length || ProtocolType == ProtocolType.Tcp && n >= 1460 || ProtocolType == ProtocolType.Udp && n >= 1464)
     //{
     //    WriteLog("接收的实际数据大小{0}超过了缓冲区大小,需要根据真实MTU调整缓冲区大小以提高效率!", n);
     //}
 }
Пример #11
0
        /// <summary>
        /// 开始异步接收数据
        /// </summary>
        /// <param name="e"></param>
        protected virtual void ReceiveAsync(NetEventArgs e)
        {
            if (!Client.IsBound) Bind();

            // 如果没有传入网络事件参数,从对象池借用
            if (e == null) e = Pop();

            if (!Client.ReceiveAsync(e)) RaiseCompleteAsync(e);
        }
Пример #12
0
        /// <summary>开始异步接收,同时处理传入的事件参数,里面可能有接收到的数据</summary>
        /// <param name="e"></param>
        internal void Start(NetEventArgs e)
        {
            if (_hasStarted) return;
            _hasStarted = true;

            if (e.BytesTransferred > 0) ProcessReceive(e);

            ReceiveAsync();
        }
Пример #13
0
        /// <summary>处理接收到的数据</summary>
        /// <param name="e"></param>
        internal protected virtual void ProcessReceive(NetEventArgs e)
        {
            // 统计接收数
            IncCounter();

            CheckBufferSize(e);
            if (Received != null)
            {
                Received(this, e);
            }
        }
Пример #14
0
 /// <summary>错误发生时。负责调用Error事件以及回收网络事件参数</summary>
 /// <remarks>OnError除了会调用ProcessError外,还会关闭Socket</remarks>
 /// <param name="e"></param>
 /// <param name="ex"></param>
 protected virtual void OnError(NetEventArgs e, Exception ex)
 {
     try
     {
         ProcessError(e, ex);
     }
     finally
     {
         Close();
     }
 }
Пример #15
0
        /// <summary>实例化</summary>
        public SocketBase()
        {
            // 子类可能重载协议类型
            LocalUri.ProtocolType = ProtocolType;
            //RemoteUri.ProtocolType = ProtocolType;

            _arg            = NetEventArgs.Pop();
            _arg.Completed += (s, e) => RaiseComplete(e as NetEventArgs);

            SetShowEventLog();
        }
Пример #16
0
        /// <summary>
        /// 接收数据。已重载。接收到0字节表示连接断开!
        /// </summary>
        /// <param name="e"></param>
        protected override void OnReceive(NetEventArgs e)
        {
            if (e.BytesTransferred > 0)
                base.OnReceive(e);
            else
            {
                //// 关闭前回收
                //Push(e);
                //Close();

                OnError(e, null);
            }
        }
Пример #17
0
        /// <summary>
        /// 异步接收
        /// </summary>
        /// <param name="e"></param>
        protected override void ReceiveAsync(NetEventArgs e)
        {
            if (!Client.IsBound) Bind();

            // 如果没有传入网络事件参数,从对象池借用
            if (e == null) e = Pop();
            //e.RemoteEndPoint = new IPEndPoint(IPAddress.Any, 0);
            // 兼容IPV6
            IPAddress address = AddressFamily == AddressFamily.InterNetworkV6 ? IPAddress.IPv6Any : IPAddress.Any;
            e.RemoteEndPoint = new IPEndPoint(address, 0);

            if (!Client.ReceiveFromAsync(e)) RaiseCompleteAsync(e);
        }
Пример #18
0
 /// <summary>
 /// 已重载。
 /// </summary>
 /// <param name="sender"></param>
 /// <param name="e"></param>
 protected override void OnReceived(object sender, NetEventArgs e)
 {
     try
     {
         if (e.BytesTransferred > 100)
             WriteLog("Discard {0} [{1}]", e.RemoteEndPoint, e.BytesTransferred);
         else
             WriteLog("Discard {0} [{1}] {2}", e.RemoteEndPoint, e.BytesTransferred, e.GetString());
     }
     finally
     {
         Disconnect(e.UserToken as SocketBase);
     }
 }
Пример #19
0
 /// <summary>错误发生/断开连接时。拦截Error事件中的所有异常,不外抛,防止因为Error异常导致多次调用OnError</summary>
 /// <param name="e"></param>
 /// <param name="ex"></param>
 internal protected void ProcessError(NetEventArgs e, Exception ex)
 {
     if (Error != null)
     {
         try
         {
             Error(this, new ExceptionEventArgs {
                 Exception = ex
             });
         }
         catch (Exception ex2)
         {
             WriteLog(ex2.ToString());
         }
     }
 }
Пример #20
0
        /// <summary>已重载。</summary>
        /// <param name="e"></param>
        protected override void OnComplete(NetEventArgs e)
        {
            switch (e.LastOperation)
            {
            case SocketAsyncOperation.Receive:
            case SocketAsyncOperation.ReceiveFrom:
            case SocketAsyncOperation.ReceiveMessageFrom:
                OnReceive(e);
                return;

            default:
                break;
            }

            base.OnComplete(e);
        }
Пример #21
0
        /// <summary>已重载。服务器不会因为普通错误而关闭Socket停止服务</summary>
        /// <param name="e"></param>
        /// <param name="ex"></param>
        protected override void OnError(NetEventArgs e, Exception ex)
        {
            var isAborted = e.SocketError == SocketError.OperationAborted;

            try
            {
                ProcessError(e, ex);
            }
            finally
            {
                if (isAborted)
                {
                    Close();
                }
            }
        }
Пример #22
0
        /// <summary>
        /// 已重载。
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected override void OnAccepted(object sender, NetEventArgs e)
        {
            try
            {
                WriteLog("Daytime {0}", e.RemoteEndPoint);

                base.OnAccepted(sender, e);

                Byte[] buffer = Encoding.ASCII.GetBytes(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.ffffff"));
                Send(e.UserToken as SocketBase, buffer, 0, buffer.Length, e.RemoteEndPoint);
            }
            finally
            {
                Disconnect(e.UserToken as SocketBase);
            }
        }
Пример #23
0
        /// <summary>接收到数据时</summary>
        /// <remarks>
        /// 网络事件参数使用原则:
        /// 1,得到者负责回收(通过方法参数得到)
        /// 2,正常执行时自己负责回收,异常时顶级负责回收
        /// 3,把回收责任交给别的方法
        /// </remarks>
        /// <param name="e"></param>
        protected virtual void OnReceive(NetEventArgs e)
        {
            // Socket错误由各个处理器来处理
            if (e.SocketError != SocketError.Success)
            {
                OnError(e, null);
                return;
            }

            // 没有接收事件时,马上开始处理重建委托
            if (Received == null)
            {
                ReceiveAsync();
                return;
            }

            Process(e, ReceiveAsync, ProcessReceive);
        }
Пример #24
0
        /// <summary>
        /// 已重载。
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected override void OnReceived(object sender, NetEventArgs e)
        {
            try
            {
                if (e.BytesTransferred > 100)
                    WriteLog("Echo {0} [{1}]", e.RemoteEndPoint, e.BytesTransferred);
                else
                    WriteLog("Echo {0} [{1}] {2}", e.RemoteEndPoint, e.BytesTransferred, e.GetString());

                Send(e.UserToken as SocketBase, e.Buffer, e.Offset, e.BytesTransferred, e.RemoteEndPoint);

                // 等一秒,等客户端接收数据
                Thread.Sleep(1000);
            }
            finally
            {
                Disconnect(e.UserToken as SocketBase);
            }
        }
Пример #25
0
        /// <summary>
        /// 已重载。
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected override void OnAccepted(object sender, NetEventArgs e)
        {
            try
            {
                WriteLog("Daytime {0}", e.RemoteEndPoint);

                base.OnAccepted(sender, e);

                TimeSpan ts = DateTime.Now - StartTime;
                Int32 s = (Int32)ts.TotalSeconds;
                // 因为要发往网络,这里调整网络字节序
                s = IPAddress.HostToNetworkOrder(s);
                Byte[] buffer = BitConverter.GetBytes(s);
                Send(e.UserToken as SocketBase, buffer, 0, buffer.Length, e.RemoteEndPoint);
            }
            finally
            {
                Disconnect(e.UserToken as SocketBase);
            }
        }
Пример #26
0
        /// <summary>把对象归还到池里</summary>
        /// <remarks>
        /// 网络事件参数使用原则:
        /// 1,得到者负责回收(通过方法参数得到)
        /// 2,正常执行时自己负责回收,异常时顶级或OnError负责回收
        /// 3,把回收责任交给别的方法
        /// 4,事件订阅者不允许回收,不允许另作他用
        /// </remarks>
        /// <param name="e"></param>
        public static void Push(NetEventArgs e)
        {
            if (e == null)
            {
                return;
            }

            e.Error          = null;
            e.UserToken      = null;
            e.Socket         = null;
            e.Session        = null;
            e.AcceptSocket   = null;
            e.RemoteEndPoint = null;

            // 清空缓冲区,避免事件池里面的对象占用内存
            //e.SetBuffer(0);
            bpool.Push(e);

            Pool.Push(e);
        }
Пример #27
0
        /// <summary>
        /// 开始异步接收数据
        /// </summary>
        /// <param name="e"></param>
        protected virtual void ReceiveAsync(NetEventArgs e)
        {
            if (!Server.IsBound) Bind();

            // 如果没有传入网络事件参数,从对象池借用
            if (e == null) e = Pop();

            //e.RemoteEndPoint = new IPEndPoint(IPAddress.Any, 0);
            // 兼容IPV6
            IPAddress address = AddressFamily == AddressFamily.InterNetworkV6 ? IPAddress.IPv6Any : IPAddress.Any;
            e.RemoteEndPoint = new IPEndPoint(address, 0);

            if (!Server.ReceiveFromAsync(e))
            {
                if (e.BytesTransferred > 0)
                    RaiseCompleteAsync(e);
                else
                    Push(e);
            }
        }
Пример #28
0
        /// <summary>
        /// 已重载。
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected override void OnReceived(object sender, NetEventArgs e)
        {
            if (e.BytesTransferred > 1024)
            {
                WriteLog("{0}的数据包大于1k,抛弃!", e.RemoteEndPoint);
                return;
            }

            //WriteLog("{0} {1}", e.RemoteEndPoint, Encoding.UTF8.GetString(e.Buffer, e.Offset, e.BytesTransferred));
            WriteLog("{0} [{1}] {2}", e.RemoteEndPoint, e.BytesTransferred, e.GetString());

            // 兼容IPV6
            IPEndPoint remote = e.RemoteEndPoint as IPEndPoint;
            if (remote != null && remote.Address != IPAddress.Any && remote.Address != IPAddress.IPv6Any)
            {
                UdpServer us = sender as UdpServer;
                us.Send(e.Buffer, e.Offset, e.BytesTransferred, e.RemoteEndPoint);
                // 这里发送完成后不需要关闭Socket,因为这是UdpServer的Socket
            }
        }
Пример #29
0
        /// <summary>
        /// 已重载。
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected override void OnAccepted(object sender, NetEventArgs e)
        {
            WriteLog("Chargen {0}", e.RemoteEndPoint);

            //if (ProtocolType == ProtocolType.Tcp)
            //{
            // 使用多线程
            Thread thread = new Thread(LoopSend);
            thread.Name = "Chargen.LoopSend";
            thread.IsBackground = true;
            thread.Priority = ThreadPriority.Lowest;
            thread.Start(new Object[] { e.UserToken, e.RemoteEndPoint });
            //}
            //else if (ProtocolType == ProtocolType.Udp)
            //{
            //    Send(e.UserToken as SocketBase, e.RemoteEndPoint as IPEndPoint);
            //}

            // 调用基类,为接收数据准备,避免占用过大内存
            base.OnAccepted(sender, e);
        }
Пример #30
0
        /// <summary>
        /// 已重载。
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected override void OnReceived(object sender, NetEventArgs e)
        {
            TcpClientX tc = sender as TcpClientX;

            try
            {
                if (e.BytesTransferred > 1024)
                {
                    WriteLog("{0}的数据包大于1k,抛弃!", tc.RemoteEndPoint);
                }
                else
                {
                    WriteLog("{0} [{1}] {2}", tc.RemoteEndPoint, e.BytesTransferred, e.GetString());

                    if (tc != null && tc.Client.Connected) tc.Send(e.Buffer, e.Offset, e.BytesTransferred);
                }
            }
            finally
            {
                tc.Close();
            }
        }
Пример #31
0
 internal void SetRemote(NetEventArgs e)
 {
     var ep = e.RemoteEndPoint as IPEndPoint;
     if ((ep == null || ep.Address.IsAny() && ep.Port == 0) && RemoteEndPoint != null) e.RemoteEndPoint = RemoteEndPoint;
 }
Пример #32
0
 /// <summary>已重载。设置RemoteEndPoint</summary>
 /// <param name="e"></param>
 protected override void OnComplete(NetEventArgs e)
 {
     SetRemote(e);
     base.OnComplete(e);
 }
Пример #33
0
        /// <summary>接收数据。已重载。接收到0字节表示连接断开!</summary>
        /// <param name="e"></param>
        protected override void OnReceive(NetEventArgs e)
        {
            if (_Received != null) SetEvent();

            //if (e.BytesTransferred > 0 || !DisconnectWhenEmptyData)
            if (e.BytesTransferred > 0)
                base.OnReceive(e);
            else
                OnError(e, null);
        }
Пример #34
0
 void TcpClientX_Received(object sender, NetEventArgs e)
 {
     if (_Received != null) _Received(this, new ReceivedEventArgs(e.GetStream()));
 }
Пример #35
0
 internal protected void CheckBufferSize(NetEventArgs e)
 {
     //Int32 n = e.BytesTransferred;
     //if (n >= e.Buffer.Length || ProtocolType == ProtocolType.Tcp && n >= 1460 || ProtocolType == ProtocolType.Udp && n >= 1464)
     //{
     //    WriteLog("接收的实际数据大小{0}超过了缓冲区大小,需要根据真实MTU调整缓冲区大小以提高效率!", n);
     //}
 }
Пример #36
0
        /// <summary>
        /// 已重载。
        /// </summary>
        /// <param name="e"></param>
        protected override void OnComplete(NetEventArgs e)
        {
            switch (e.LastOperation)
            {
                case SocketAsyncOperation.Accept:
                    break;
                case SocketAsyncOperation.Connect:
                    break;
                case SocketAsyncOperation.Disconnect:
                    break;
                case SocketAsyncOperation.None:
                    break;
                case SocketAsyncOperation.Receive:
                case SocketAsyncOperation.ReceiveFrom:
                case SocketAsyncOperation.ReceiveMessageFrom:
                    OnReceive(e);
                    return;
                case SocketAsyncOperation.Send:
                    break;
                case SocketAsyncOperation.SendPackets:
                    break;
                case SocketAsyncOperation.SendTo:
                    break;
                default:
                    break;
            }

            base.OnComplete(e);
        }
Пример #37
0
        /// <summary>
        /// 处理接收
        /// </summary>
        /// <param name="e"></param>
        private void ProcessReceive(NetEventArgs e)
        {
            if (NoDelay && e.SocketError != SocketError.OperationAborted) ReceiveAsync();

            try
            {
                // Socket错误由各个处理器来处理
                if (e.SocketError != SocketError.Success)
                {
                    OnError(e, null);
                    // OnError里面已经被回收,赋值为null,否则后面finally里面的Push会出错
                    e = null;
                    return;
                }

#if DEBUG
                Int32 n = e.BytesTransferred;
                if (n >= e.Buffer.Length || ProtocolType == ProtocolType.Tcp && n >= 1452 || ProtocolType == ProtocolType.Udp && n >= 1464)
                {
                    WriteLog("接收的实际数据大小{0}超过了缓冲区大小,需要根据真实MTU调整缓冲区大小以提高效率!", n);
                }
#endif

                if (Received != null) Received(this, e);
            }
            finally
            {
                if (NoDelay)
                    Push(e);
                else
                    ReceiveAsync(e);
            }
        }
Пример #38
0
 void ShowEvent(NetEventArgs e)
 {
     //WriteLog("Completed[{4}] {0} {1} {2} [{3}]", this, e.LastOperation, e.SocketError, e.BytesTransferred, e.ID);
     var sb = new StringBuilder();
     sb.AppendFormat("[{0}] {1} {2}://{3}", e.ID, e.LastOperation, ProtocolType, LocalEndPoint);
     var ep = e.RemoteIPEndPoint;
     //if (ep == null || ep.Address.IsAny()) ep = RemoteEndPoint;
     if ((ep == null || ep.Address.IsAny()) && e.LastOperation == SocketAsyncOperation.Accept && e.AcceptSocket != null) ep = e.AcceptSocket.RemoteEndPoint as IPEndPoint;
     if (ep != null && !ep.Address.IsAny()) sb.AppendFormat("=>{0}", ep);
     //sb.AppendFormat(" {0}", e.LastOperation);
     if (e.SocketError != SocketError.Success) sb.AppendFormat(" {0}", e.SocketError);
     sb.AppendFormat(" [{0}]", e.BytesTransferred);
     WriteLog(sb.ToString());
 }
Пример #39
0
        /// <summary>处理接收到的数据</summary>
        /// <param name="e"></param>
        protected internal override void ProcessReceive(NetEventArgs e)
        {
            if (e.Session == null) e.Session = CreateSession();

            base.ProcessReceive(e);
        }
Пример #40
0
        /// <summary>处理异步结果。</summary>
        /// <param name="e">事件参数</param>
        /// <param name="start">开始新异步操作的委托</param>
        /// <param name="process">处理结果的委托</param>
        protected virtual void Process(NetEventArgs e, Func start, Action<NetEventArgs> process)
        {
            // Socket错误由各个处理器来处理
            if (e.SocketError != SocketError.Success)
            {
                OnError(e, null);
                return;
            }

            try
            {
                // 业务处理的任何异常,都将引发Error事件,但不会影响重新建立新的异步操作
                process(e);
            }
            catch (Exception ex)
            {
                try
                {
                    OnError(e, ex);
                }
                catch { }

                return;
            }

            // 如果不是操作取消,在处理业务完成后再开始异步操作
            if (!Disposed) start();
        }
Пример #41
0
 /// <summary>错误发生/断开连接时。拦截Error事件中的所有异常,不外抛,防止因为Error异常导致多次调用OnError</summary>
 /// <param name="e"></param>
 /// <param name="ex"></param>
 internal protected void ProcessError(NetEventArgs e, Exception ex)
 {
     if (Error != null)
     {
         try
         {
             Error(this, new ExceptionEventArgs { Exception = ex });
         }
         catch (Exception ex2)
         {
             WriteLog(ex2.ToString());
         }
     }
 }
Пример #42
0
 /// <summary>错误发生时。负责调用Error事件以及回收网络事件参数</summary>
 /// <remarks>OnError除了会调用ProcessError外,还会关闭Socket</remarks>
 /// <param name="e"></param>
 /// <param name="ex"></param>
 protected virtual void OnError(NetEventArgs e, Exception ex)
 {
     try
     {
         ProcessError(e, ex);
     }
     finally
     {
         Close();
     }
 }
Пример #43
0
 /// <summary>完成事件分发中心。
 /// 正常执行时OnComplete必须保证回收参数e,异常时RaiseComplete将能够代为回收
 /// </summary>
 /// <param name="e"></param>
 protected virtual void OnComplete(NetEventArgs e)
 {
 }
Пример #44
0
        /// <summary>
        /// 接收到数据时
        /// </summary>
        /// <param name="e"></param>
        protected virtual void OnReceive(NetEventArgs e)
        {
            // Socket错误由各个处理器来处理
            if (e.SocketError == SocketError.OperationAborted)
            {
                OnError(e, null);
                return;
            }

            // 没有接收事件时,马上开始处理重建委托
            if (Received == null)
            {
                ReceiveAsync(e);
                return;
            }

            //ProcessReceive(e);
            // 这里可以改造为使用多线程处理事件

            ThreadPoolCallback(ProcessReceive, e);
        }
Пример #45
0
        static void server_Accepted(object sender, NetEventArgs e)
        {
            TcpSession session = e.UserToken as TcpSession;
            if (session == null) return;

            //if (e.AcceptSocket != null)
            //    Console.WriteLine("{1} 新连接 {0}", e.AcceptSocket.RemoteEndPoint, session.ID);
            //else
            if (e.AcceptSocket == null)
                Console.WriteLine("奇怪");

            //SetEvent(session, true);

            //XTrace.WriteLine(e.GetString());
            //session.Send("欢迎!");
            session.Send(e.GetString());

            session.Push(e);
            session.Close();
        }