예제 #1
0
 /// <summary>
 /// 开始异步接收,同时处理传入的事件参数,里面可能有接收到的数据
 /// </summary>
 /// <param name="e"></param>
 internal new void ReceiveAsync(DME_NetEventArgs e)
 {
     if (e.BytesTransferred > 0)
         OnReceive(e);
     else
         base.ReceiveAsync(e);
 }
예제 #2
0
        void server_Accepted(object sender, DME_NetEventArgs e)
        {
            DME_TcpClient session = e.UserToken as DME_TcpClient;
            if (session == null) return;

            //session.NoDelay = false;
            SetEvent(session);
        }
예제 #3
0
        /// <summary>
        /// 接受连接时
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected virtual void OnAccepted(Object sender, DME_NetEventArgs e)
        {
            DME_TcpClient session = e.UserToken as DME_TcpClient;
            if (session == null) return;

            session.Received += OnReceived;
            session.Error += new EventHandler<DME_NetEventArgs>(OnError);
        }
예제 #4
0
        /// <summary>
        /// 异步接收
        /// </summary>
        /// <param name="e"></param>
        protected override void ReceiveAsync(DME_NetEventArgs e)
        {
            if (!Client.IsBound) Bind();

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

            if (!Client.ReceiveFromAsync(e)) RaiseCompleteAsync(e);
        }
예제 #5
0
        /// <summary>
        /// 接收数据。已重载。接收到0字节表示连接断开!
        /// </summary>
        /// <param name="e"></param>
        protected override void OnReceive(DME_NetEventArgs e)
        {
            if (e.BytesTransferred > 0)
                base.OnReceive(e);
            else
            {
                //// 关闭前回收
                //Push(e);
                //Close();

                OnError(e, null);
            }
        }
예제 #6
0
        /// <summary>
        /// 已重载。
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected override void OnReceived(object sender, DME_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());

            if ((e.RemoteEndPoint as IPEndPoint).Address != IPAddress.Any)
            {
                DME_UdpServer us = sender as DME_UdpServer;
                us.Send(e.Buffer, e.Offset, e.BytesTransferred, e.RemoteEndPoint);
                // 这里发送完成后不需要关闭Socket,因为这是UdpServer的Socket
            }
        }
예제 #7
0
        /// <summary>
        /// 已重载。
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected override void OnReceived(object sender, DME_NetEventArgs e)
        {
            DME_TcpClient tc = sender as DME_TcpClient;

            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();
            }
        }
예제 #8
0
 /// <summary>
 /// 创建会话
 /// </summary>
 /// <param name="e"></param>
 /// <returns></returns>
 protected virtual DME_TcpSession CreateSession(DME_NetEventArgs e)
 {
     DME_TcpSession session = new DME_TcpSession();
     session.Socket = e.AcceptSocket;
     session.RemoteEndPoint = e.AcceptSocket.RemoteEndPoint as IPEndPoint;
     Sessions.Add(session);
     return session;
 }
예제 #9
0
        /// <summary>
        /// 已重载。
        /// </summary>
        /// <param name="e"></param>
        protected override void OnComplete(DME_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);
        }
예제 #10
0
 /// <summary>
 /// 在线程池里面执行指定委托。内部会处理异常并调用OnError
 /// </summary>
 /// <param name="callback"></param>
 /// <param name="e"></param>
 protected void ThreadPoolCallback(Action<DME_NetEventArgs> callback, DME_NetEventArgs e)
 {
     if (UseThreadPool)
     {
         ThreadPool.QueueUserWorkItem(delegate(Object state)
         {
             try
             {
                 callback(state as DME_NetEventArgs);
             }
             catch (Exception ex)
             {
                 try
                 {
                     OnError(state as DME_NetEventArgs, ex);
                 }
                 catch { }
                 // 都是在线程池线程里面了,不要往外抛出异常
                 //throw;
             }
         }, e);
     }
     else
     {
         callback(e);
     }
 }
예제 #11
0
        /// <summary>
        /// 新客户端到达
        /// </summary>
        /// <param name="e"></param>
        protected virtual void OnAccept(DME_NetEventArgs e)
        {
            // 再次开始
            if (e.SocketError != SocketError.OperationAborted) StartAccept();

            // Socket错误由各个处理器来处理
            if (e.SocketError != SocketError.Success)
            {
                OnError(e, null);
                return;
            }

            // 建立会话
            DME_TcpSession session = CreateSession(e);
            session.NoDelay = this.NoDelay;
            e.UserToken = session;
            if (Accepted != null) Accepted(this, e);

            if (session.Socket != null && session.Socket.Connected) session.ReceiveAsync(e);
        }
예제 #12
0
 /// <summary>
 /// 收到数据时
 /// </summary>
 /// <param name="sender"></param>
 /// <param name="e"></param>
 protected virtual void OnReceived(Object sender, DME_NetEventArgs e)
 {
 }
예제 #13
0
 /// <summary>
 /// 异步触发完成事件处理程序
 /// </summary>
 /// <param name="e"></param>
 protected void RaiseCompleteAsync(DME_NetEventArgs e)
 {
     if (UseThreadPool)
     {
         ThreadPool.QueueUserWorkItem(delegate(Object state)
         {
             RaiseComplete(state as DME_NetEventArgs);
         }, e);
     }
     else
     {
         RaiseComplete(e);
     }
 }
예제 #14
0
 /// <summary>
 /// 错误发生时。负责调用Error事件以及回收网络事件参数
 /// </summary>
 /// <remarks>OnError除了会调用ProcessError外,还会关闭Socket</remarks>
 /// <param name="e"></param>
 /// <param name="ex"></param>
 protected virtual void OnError(DME_NetEventArgs e, Exception ex)
 {
     try
     {
         ProcessError(e, ex);
     }
     finally
     {
         Close();
     }
 }
예제 #15
0
        /// <summary>
        /// 处理接收
        /// </summary>
        /// <param name="e"></param>
        private void ProcessReceive(DME_NetEventArgs e)
        {
            if (NoDelay) ReceiveAsync();

            if (Received != null) Received(this, e);

            if (NoDelay)
                Push(e);
            else
                ReceiveAsync(e);
        }
예제 #16
0
        /// <summary>
        /// 把对象归还到池里
        /// </summary>
        /// <remarks>
        /// 网络事件参数使用原则:
        /// 1,得到者负责回收(通过方法参数得到)
        /// 2,正常执行时自己负责回收,异常时顶级负责回收
        /// 3,把回收责任交给别的方法
        /// </remarks>
        /// <param name="e"></param>
        public void Push(DME_NetEventArgs e)
        {
            if (e == null) return;
            if (!e.Used) throw new Exception("准备回炉,怎么可能已经不再使用呢?");

            e.UserToken = null;
            e.AcceptSocket = null;
            e.Completed -= OnCompleted;

            e.Used = false;

            Pool.Push(e);
        }
예제 #17
0
        /// <summary>
        /// 接收到数据时
        /// </summary>
        /// <param name="e"></param>
        protected virtual void OnReceive(DME_NetEventArgs e)
        {
            // Socket错误由各个处理器来处理
            if (e.SocketError == SocketError.OperationAborted)
            {
                OnError(e, null);
                return;
            }

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

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

            ThreadPoolCallback(ProcessReceive, e);
        }
예제 #18
0
 /// <summary>
 /// 断开连接/发生错误
 /// </summary>
 /// <param name="sender"></param>
 /// <param name="e"></param>
 protected virtual void OnError(object sender, DME_NetEventArgs e)
 {
     if (e.SocketError != SocketError.Success || e.UserToken is Exception)
         WriteLog("{2}错误 {0} {1}", e.SocketError, e.UserToken as Exception, e.LastOperation);
     else
         WriteLog("{0}断开!", e.LastOperation);
 }
예제 #19
0
 /// <summary>
 /// 已重载。服务器不会因为普通错误而关闭Socket停止服务
 /// </summary>
 /// <param name="e"></param>
 /// <param name="ex"></param>
 protected override void OnError(DME_NetEventArgs e, Exception ex)
 {
     //base.OnError(e, ex);
     try
     {
         ProcessError(e, ex);
     }
     finally
     {
         if (e.SocketError == SocketError.OperationAborted) Close();
     }
 }
예제 #20
0
 /// <summary>
 /// 已重载。
 /// </summary>
 /// <param name="sender"></param>
 /// <param name="e"></param>
 protected override void OnReceived(object sender, DME_NetEventArgs e)
 {
     if (e.BytesTransferred > 0) DME_StreamHandlerFactory.Process(StreamHandlerFactoryName, e.GetStream());
 }
예제 #21
0
        /// <summary>
        /// 接收到数据时
        /// </summary>
        /// <remarks>
        /// 网络事件参数使用原则:
        /// 1,得到者负责回收(通过方法参数得到)
        /// 2,正常执行时自己负责回收,异常时顶级负责回收
        /// 3,把回收责任交给别的方法
        /// </remarks>
        /// <param name="e"></param>
        protected virtual void OnReceive(DME_NetEventArgs e)
        {
            // Socket错误由各个处理器来处理
            if (e.SocketError != SocketError.Success)
            {
                OnError(e, null);
                return;
            }

            // 没有接收事件时,马上开始处理重建委托
            if (Received == null)
            {
                // 3,把回收责任交给别的方法
                ReceiveAsync(e);
                return;
            }

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

            // 3,把回收责任交给别的方法
            ThreadPoolCallback(ProcessReceive, e);
        }
예제 #22
0
        /// <summary>
        /// 错误发生/断开连接时。拦截Error事件中的所有异常,不外抛,防止因为Error异常导致多次调用OnError
        /// </summary>
        /// <param name="e"></param>
        /// <param name="ex"></param>
        protected void ProcessError(DME_NetEventArgs e, Exception ex)
        {
            if (Error != null)
            {
                if (ex != null)
                {
                    if (e == null) e = Pop();
                    e.UserToken = ex;
                }

                try
                {
                    Error(this, e);
                }
                catch (Exception ex2)
                {
                    WriteLog(ex2.ToString());
                }
            }

            // 不管有没有外部事件,都要归还网络事件参数,那是对象池的东西,不是你的
            if (e != null) Push(e);
        }
예제 #23
0
        /// <summary>
        /// 开始异步接收数据
        /// </summary>
        /// <param name="e"></param>
        protected virtual void ReceiveAsync(DME_NetEventArgs e)
        {
            if (!Client.IsBound) Bind();

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

            if (!Client.ReceiveAsync(e)) RaiseCompleteAsync(e);
        }
예제 #24
0
        /// <summary>
        /// 触发完成事件。
        /// 可能由工作线程(事件触发)调用,也可能由用户线程通过线程池线程调用。
        /// 作为顶级,将会处理所有异常并调用OnError,其中OnError有能力回收参数e。
        /// </summary>
        /// <param name="e"></param>
        protected void RaiseComplete(DME_NetEventArgs e)
        {
            try
            {
                if (Completed != null) Completed(this, e);

                OnComplete(e);
                // 这里可以改造为使用多线程处理事件
                //ThreadPoolCallback(OnCompleted, e);
            }
            catch (Exception ex)
            {
                OnError(e, ex);
                // 都是在线程池线程里面了,不要往外抛出异常
                //throw;
            }
        }
예제 #25
0
 /// <summary>
 /// 完成事件分发中心。
 /// 正常执行时OnComplete必须保证回收参数e,异常时RaiseComplete将能够代为回收
 /// </summary>
 /// <param name="e"></param>
 protected virtual void OnComplete(DME_NetEventArgs e)
 {
 }
예제 #26
0
        /// <summary>
        /// 处理接收
        /// </summary>
        /// <param name="e"></param>
        private void ProcessReceive(DME_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 (Received != null) Received(this, e);
            }
            finally
            {
                if (NoDelay)
                    Push(e);
                else
                    ReceiveAsync(e);
            }
        }