C# CloseStatusCode.IsReserved方法代码示例

        /// <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 length of <paramref name="reason"/>
        /// is greater than 123 bytes.
        /// </remarks>
        /// <param name="code">
        /// One of the <see cref="CloseStatusCode"/> values that indicate the status codes for closure.
        /// </param>
        /// <param name="reason">
        /// A <see cref="string"/> that contains the reason for closure.
        /// </param>
        public void Close(CloseStatusCode code, string reason)
        {
            var data = ((ushort) code).Append (reason);
              var msg = data.CheckIfValidCloseData ();
              if (msg != null)
              {
            _logger.Error (String.Format ("{0}\nreason: {1}", msg, reason));
            error (msg);

            return;
              }

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

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

        /// <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 closure.
        /// </param>
        /// <param name="reason">
        /// A <see cref="string"/> that represents the reason for closure.
        /// </param>
        public void CloseAsync(CloseStatusCode code, string reason)
        {
            byte [] data = null;
              var msg = _readyState.CheckIfClosable () ??
                (data = ((ushort) code).Append (reason)).CheckIfValidControlData ("reason");

              if (msg != null) {
            _logger.Error (String.Format ("{0}\ncode: {1} reason: {2}", msg, code, reason));
            error (msg);

            return;
              }

              var send = _readyState == WebSocketState.Open && !code.IsReserved ();
              closeAsync (new PayloadData (data), 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)
    {
      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);
    }

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

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

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

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

 private void fatal(string message, CloseStatusCode code)
 {
     var payload = new PayloadData ((ushort) code, message);
       close (payload, !code.IsReserved (), false, false);
 }

        /// <summary>
        /// Closes the WebSocket connection asynchronously with the specified
        /// <paramref name="code"/> and <paramref name="reason"/>, and releases
        /// all associated resources.
        /// </summary>
        /// <remarks>
        /// This method does not wait for the close to be complete.
        /// </remarks>
        /// <param name="code">
        /// One of the <see cref="CloseStatusCode"/> enum values that 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.
        /// The size must be 123 bytes or less.
        /// </param>
        public void CloseAsync(CloseStatusCode code, string reason)
        {
            string msg;
            if (!checkIfAvailable(true, true, false, false, out msg))
            {
#if COMPAT
                Log.Error(msg);
#else
                msg.Error();
#endif
                Error("An error has occurred in closing the connection.", null);

                return;
            }

            if (!CheckParametersForClose(code, reason, _client, out msg))
            {
#if COMPAT
                Log.Error(msg);
#else
                msg.Error();
#endif
                Error("An error has occurred in closing the connection.", null);

                return;
            }

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

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