void OnCloseInternal(object sender, CloseEventArgs e)
 {
     if (OnClose != null)
     {
         OnClose(this, e.Reason);
     }
 }

        protected override void OnClose(CloseEventArgs e)
        {
            Program.Users.Remove(User);

            //test
            Program.Chanels.Remove(_test);
        }

 protected override void OnClose(CloseEventArgs e)
 {
     log_.Info("closed");
     EventHandler<CloseEventArgs> handler = OnCloseEvent;
     if (handler != null)
     {
         handler(this, e);
     }
 }

        void OnSocketClose(object sender, CloseEventArgs e)
        {
            if (_webSocket == null)
            {
                throw new ApplicationException("_webSocket can't be null");
            }

            Log.Write("WARN: RTM websocket closed. Reconnecting in a few seconds...");
            Thread.Sleep(5000);
            ConnectRtm();
        }

 protected override void OnClose(CloseEventArgs e)
 {
     WSGroupServices.GetLogger().Info("Socket closed");
     foreach (var client in _clients)
     {
         if (!client.Value.IsAlive && DoesFilterMatchIncomingNodeName(client.Key, WSGroupServices.GetFilter()))
         {
             ApplyOnDisconnect(client);
         }
     }
 }

        private void Client_Close(CloseEventArgs e)
        {
            if (InvokeRequired)
            {
                Invoke((MethodInvoker)delegate {
                    Client_Close(e);
                });
                return;
            }

            status.Text = "Connection closed.";
        }

 protected override void OnClose(CloseEventArgs e)
 {
     Program.Users.Remove(User);
     try
     {
         Channel _chan = Program.Chanels.Single(a => a.UserIn(User) == true);
         if (_chan != null)
         {
             _chan.RemoveUser(User);
         }
     }
     catch { }
 }

        protected override void OnClose(CloseEventArgs e) {
            this.isReady = false;

            if (this.onClose != null) {
                this.onClose();
            }

            if (Settings.debug.info) {
                Debug.Log("AirConsole: screen.html disconnected");
            }
           
            base.OnClose(e);
        }

		private void OnClose(object sender, CloseEventArgs e)
		{
			EmitEvent("close");
		}

 protected override void OnClose(CloseEventArgs e) {
   if(true) {
     X13.Log.Info("{0} Disconnect: [{1}]{2}", this.ToString(), e.Code, e.Reason);
   }
   if(_owner!=null) {
     _owner.Remove();
   }
 }

 protected override void OnClose(CloseEventArgs e)
 {
     var msg = String.Format("{0} got logged off...", _name);
       Broadcast(msg);
 }

 private void OnCloseHandler(object sender, CloseEventArgs e) {
     Debug.Log("WebSocket closed with reason: " + e.Reason);
 }

        // As server
        internal void Close(CloseEventArgs args, byte [] frameAsBytes, int waitTimeOut)
        {
            lock (_forClose)
              {
            if (_readyState == WebSocketState.CLOSING || _readyState == WebSocketState.CLOSED)
              return;

            _readyState = WebSocketState.CLOSING;
              }

              args.WasClean = close (frameAsBytes, waitTimeOut, closeServerResources);

              _readyState = WebSocketState.CLOSED;

              OnClose.Emit (this, args);
        }

 private void closeAsync (CloseEventArgs e, bool send, bool wait)
 {
   Action<CloseEventArgs, bool, bool> closer = close;
   closer.BeginInvoke (e, send, wait, ar => closer.EndInvoke (ar), null);
 }

    // As server
    internal void Close (CloseEventArgs e, byte[] frameAsBytes, TimeSpan timeout)
    {
      lock (_forConn) {
        if (_readyState == WebSocketState.Closing) {
          _logger.Info ("The closing is already in progress.");
          return;
        }

        if (_readyState == WebSocketState.Closed) {
          _logger.Info ("The connection has been closed.");
          return;
        }

        _readyState = WebSocketState.Closing;
      }

      e.WasClean = closeHandshake (frameAsBytes, timeout, releaseServerResources);

      _readyState = WebSocketState.Closed;
      try {
        OnClose.Emit (this, e);
      }
      catch (Exception ex) {
        _logger.Fatal (ex.ToString ());
      }
    }

        // As server
        internal void Close(CloseEventArgs args, byte [] frame, int timeout)
        {
            lock (_forConn) {
            if (_readyState == WebSocketState.Closing || _readyState == WebSocketState.Closed) {
              _logger.Info ("Closing the WebSocket connection has already been done.");
              return;
            }

            _readyState = WebSocketState.Closing;
              }

              args.WasClean = closeHandshake (frame, timeout, closeServerResources);

              _readyState = WebSocketState.Closed;
              try {
            OnClose.Emit (this, args);
              }
              catch (Exception ex) {
            _logger.Fatal (ex.ToString ());
              }
        }

 private void Socket_OnClose(object sender, CloseEventArgs e)
 {
     LogHelper.Info("Koala连接关闭->" + e.Reason);
     IsConnected = false;
     reset.Set();
 }

 void ws_OnClose(object sender, CloseEventArgs e)
 {
     Debug.Print("Closed For" + e.Reason);
     listBox1.WFUIize(() => listBox1.Items.Add("Errored: " + e.Reason));
 }

 private void _ws_OnClose(object sender, CloseEventArgs e) {
   if(_verbose.value) {
     if(e.Code==1000) {
       Log.Info("WsSync/{0} - disconnected[{1}]", name, e.Code);
     } else {
       Log.Warning("WsSync/{0} - disconnected[{1}]", name, e.Code);
     }
   }
   _present.value=false;
   if(_st==State.Dispose) {
     _reconn.Change(-1, -1);
     _ws=null;
   }
 }

        /// <summary>
        /// Closes the WebSocket connection asynchronously with the specified
        /// <see cref="CloseStatusCode"/> and <see cref="string"/>, and releases
        /// all associated resources.
        /// </summary>
        /// <remarks>
        ///   <para>
        ///   This method doesn't wait for the close to be complete.
        ///   </para>
        ///   <para>
        ///   This method emits a <see cref="OnError"/> event if the size of <paramref name="reason"/>
        ///   is greater than 123 bytes.
        ///   </para>
        /// </remarks>
        /// <param name="code">
        /// One of the <see cref="CloseStatusCode"/> enum values, represents the status code
        /// indicating the reason for the close.
        /// </param>
        /// <param name="reason">
        /// A <see cref="string"/> that represents the reason for the close.
        /// </param>
        public void CloseAsync(CloseStatusCode code, string reason)
        {
            CloseEventArgs e = null;
              var msg = _readyState.CheckIfClosable () ??
                (e = new CloseEventArgs (code, reason)).RawData.CheckIfValidControlData ("reason");

              if (msg != null) {
            _logger.Error (msg);
            error ("An error has occurred in closing the connection.", null);

            return;
              }

              var send = _readyState == WebSocketState.Open && !code.IsReserved ();
              closeAsync (e, send, send);
        }