internal WebSocketException(
   CloseStatusCode code, string message, Exception innerException
 )
         : base(message ?? code.GetMessage (), innerException)
     {
         _code = code;
     }

        public void Disconnect(Action callback, CloseStatusCode code = CloseStatusCode.NoStatus, string reason = null)
        {
            if (_conn != null)
            {
                // _conn.OnClose(); //TODO how to clear event handler?
                if (code != CloseStatusCode.NoStatus)
                {
                    _conn.Close(code, reason);
                }

                _conn = null;
            }

            if (callback != null) callback();
        }

 /// <summary>
 /// Closes the session with the specified <paramref name="id"/>, <paramref name="code"/>,
 /// and <paramref name="reason"/>.
 /// </summary>
 /// <param name="id">
 /// A <see cref="string"/> that represents the ID of the session to close.
 /// </param>
 /// <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 CloseSession(string id, CloseStatusCode code, string reason)
 {
     IWebSocketSession session;
       if (TryGetSession (id, out session))
     session.Context.WebSocket.Close (code, reason);
 }

 /// <summary>
 /// Closes the WebSocket connection with the specified <see cref="CloseStatusCode"/>,
 /// and releases all associated resources.
 /// </summary>
 /// <param name="code">
 /// One of the <see cref="CloseStatusCode"/> values that indicate the status codes for closure.
 /// </param>
 public void Close(CloseStatusCode code)
 {
     var send = _readyState == WebSocketState.OPEN && !code.IsReserved ();
       close (new PayloadData (((ushort) code).ToByteArrayInternally (ByteOrder.BIG)), send, true);
 }

 private void close(CloseStatusCode code, string reason, bool wait)
 {
     close (new PayloadData (((ushort) code).Append (reason)), !code.IsReserved (), wait);
 }

 internal static string CheckCloseParameters (CloseStatusCode code, string reason, bool client)
 {
   return code == CloseStatusCode.NoStatus
          ? (!reason.IsNullOrEmpty () ? "NoStatus cannot have a reason." : null)
          : code == CloseStatusCode.MandatoryExtension && !client
            ? "MandatoryExtension cannot be used by a server."
            : code == CloseStatusCode.ServerError && client
              ? "ServerError cannot be used by a client."
              : !reason.IsNullOrEmpty () && reason.UTF8Encode ().Length > 123
                ? "A reason has greater than the allowable max size."
                : null;
 }

 /// <summary>
 /// Closes the WebSocket connection asynchronously with the specified
 /// <see cref="CloseStatusCode"/>, and releases all associated resources.
 /// </summary>
 /// <remarks>
 /// This method doesn't wait for the close to be complete.
 /// </remarks>
 /// <param name="code">
 /// One of the <see cref="CloseStatusCode"/> enum values, represents the status code indicating
 /// the reason for closure.
 /// </param>
 public void CloseAsync(CloseStatusCode code)
 {
     CloseAsync (code, null);
 }

 /// <summary>
 /// Stops the current <see cref="WebSocketService"/> instance with the specified
 /// <see cref="CloseStatusCode"/> and <see cref="string"/>.
 /// </summary>
 /// <param name="code">
 /// One of the <see cref="CloseStatusCode"/> values that indicates a status code
 /// indicating the reason for stop.
 /// </param>
 /// <param name="reason">
 /// A <see cref="string"/> that contains the reason for stop.
 /// </param>
 public void Stop(CloseStatusCode code, string reason)
 {
     if (IsBound)
     _websocket.Close (code, reason);
 }

 private void fatal (string message, CloseStatusCode code)
 {
   close (new CloseEventArgs (code, message), !code.IsReserved (), false, false);
 }

 /// <summary>
 /// Closes the WebSocket connection with the specified <paramref name="code"/> and
 /// releases all associated resources.
 /// </summary>
 /// <param name="code">
 /// One of the <see cref="CloseStatusCode"/> values that indicates the status code for closure.
 /// </param>
 public void Close(CloseStatusCode code)
 {
     close((ushort)code, String.Empty);
 }

    /// <summary>
    /// Closes the WebSocket connection asynchronously with the specified
    /// <see cref="CloseStatusCode"/>, and releases all associated resources.
    /// </summary>
    /// <remarks>
    /// This method doesn't wait for the close to be complete.
    /// </remarks>
    /// <param name="code">
    /// One of the <see cref="CloseStatusCode"/> enum values, represents the status code
    /// indicating the reason for the close.
    /// </param>
    public void CloseAsync (CloseStatusCode code)
    {
      var msg = _readyState.CheckIfClosable ();
      if (msg != null) {
        _logger.Error (msg);
        error ("An error has occurred in closing the connection.", null);

        return;
      }

      if (code.IsNoStatusCode ()) {
        closeAsync (new CloseEventArgs (), true, true);
        return;
      }

      var send = !code.IsReserved ();
      closeAsync (new CloseEventArgs (code), send, send);
    }

        /// <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);
        }

        /// <summary>
        /// Closes the WebSocket connection with the specified <see cref="CloseStatusCode"/>,
        /// and releases all associated resources.
        /// </summary>
        /// <param name="code">
        /// One of the <see cref="CloseStatusCode"/> enum values, represents the status code
        /// indicating the reason for the close.
        /// </param>
        public void Close(CloseStatusCode code)
        {
            var msg = _readyState.CheckIfClosable ();
              if (msg != null) {
            _logger.Error (msg);
            error ("An error has occurred in closing the connection.", null);

            return;
              }

              var send = _readyState == WebSocketState.Open && !code.IsReserved ();
              close (new CloseEventArgs (code), send, send);
        }

        private bool processUnsupportedFrame(WebSocketFrame frame, CloseStatusCode code, string reason)
        {
            processException(new WebSocketException(code, reason), null);

            return false;
        }

        /// <summary>
        /// Closes the WebSocket connection with the specified <see cref="CloseStatusCode"/>
        /// and <see cref="string"/>, and releases all associated resources.
        /// </summary>
        /// <remarks>
        /// This method emits a <see cref="OnError"/> event if the size
        /// of <paramref name="reason"/> is greater than 123 bytes.
        /// </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 Close(CloseStatusCode code, string reason)
        {
            byte[] data = null;
            var msg = _readyState.CheckIfClosable() ??
                      (data = ((ushort)code).Append(reason)).CheckIfValidControlData("reason");

            if (msg != null)
            {
                error(msg);

                return;
            }

            var send = _readyState == WebSocketState.Open && !code.IsReserved();
            close(new PayloadData(data), send, send);
        }

 internal CloseEventArgs (CloseStatusCode code)
   : this ((ushort) code)
 {
 }

 /// <summary>
 /// Closes the WebSocket connection with the specified <paramref name="code"/> and
 /// releases all associated resources.
 /// </summary>
 /// <param name="code">
 /// One of the <see cref="CloseStatusCode"/> values that indicates the status code for closure.
 /// </param>
 public void Close(CloseStatusCode code)
 {
     close (new PayloadData (((ushort) code).ToByteArray (ByteOrder.BIG)));
 }

 /// <summary>
 /// Closes the WebSocket connection with the specified <see cref="CloseStatusCode"/>, and
 /// releases all associated resources.
 /// </summary>
 /// <param name="code">
 /// One of the <see cref="CloseStatusCode"/> enum values, represents the status code indicating
 /// the reason for closure.
 /// </param>
 public void Close(CloseStatusCode code)
 {
     Close (code, null);
 }

 internal WebSocketException (CloseStatusCode code, Exception innerException)
   : this (code, null, innerException)
 {
 }

    /// <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)
    {
      var msg = _readyState.CheckIfAvailable (true, true, false, false) ??
                CheckCloseParameters (code, reason, _client);

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

        return;
      }

      if (code == CloseStatusCode.NoStatus) {
        closeAsync (new CloseEventArgs (), true, true);
        return;
      }

      var send = !code.IsReserved ();
      closeAsync (new CloseEventArgs (code, reason), send, send);
    }