C# WebSocketError类代码示例

 public void ConstructorTests_WebSocketError_Success(WebSocketError error)
 {
     var wse = new WebSocketException(error);
     Assert.Equal(error, wse.WebSocketErrorCode);
     Assert.NotEqual("", wse.Message);
     Assert.Null(wse.InnerException);
 }

 public void ConstructorTests_NativeError_Success(int nativeError, WebSocketError webSocketError)
 {
     var wse = new WebSocketException(nativeError);
     Assert.Equal(wse.HResult, nativeError);
     Assert.Equal(wse.WebSocketErrorCode, webSocketError);
     Assert.NotEqual(wse.Message, "");
     Assert.Null(wse.InnerException);
 }

 public void ConstructorTests_WebSocketError_Exception_Success(WebSocketError error)
 {
     var inner = new Exception();
     var wse = new WebSocketException(error, inner);
     Assert.Equal(error, wse.WebSocketErrorCode);
     Assert.NotEqual("", wse.Message);
     Assert.Same(inner, wse.InnerException);
 }

 public void ConstructorTests_NativeError_Success(int nativeError, WebSocketError webSocketError, int expectedHResult)
 {
     var wse = new WebSocketException(nativeError);
     Assert.Equal(expectedHResult, wse.HResult);
     Assert.Equal(webSocketError, wse.WebSocketErrorCode);
     Assert.NotEqual("", wse.Message);
     Assert.Null(wse.InnerException);
 }

 public void ConstructorTests_WebSocketError_Message_Success(WebSocketError error)
 {
     const string Message = "Message";
     var wse = new WebSocketException(error, Message);
     Assert.Equal(error, wse.WebSocketErrorCode);
     Assert.Equal(Message, wse.Message);
     Assert.Null(wse.InnerException);
 }

 public void ConstructorTests_WebSocketError_Message_Exception_Success(WebSocketError error)
 {
     const string Message = "Message";
     var inner = new Exception();
     var wse = new WebSocketException(error, Message, inner);
     Assert.Equal(wse.WebSocketErrorCode, error);
     Assert.Equal(wse.Message, Message);
     Assert.Equal(wse.InnerException, inner);
 }

 public void ConstructorTests_NativeError_Message_Success(int nativeError, WebSocketError webSocketError)
 {
     const string Message = "Message";
     var wse = new WebSocketException(nativeError, Message);
     Assert.Equal(wse.HResult, nativeError);
     Assert.Equal(wse.WebSocketErrorCode, webSocketError);
     Assert.Equal(wse.Message, Message);
     Assert.Null(wse.InnerException);
 }

		public WebSocketException (WebSocketError error, int nativeError) : this (error, nativeError, DefaultMessage, null)
		{
		}

 public void ConstructorTests_WebSocketError_NativeError_Exception_Success(int nativeError, WebSocketError error)
 {
     var inner = new Exception();
     var wse = new WebSocketException(error, nativeError, inner);
     Assert.Equal(wse.HResult, nativeError);
     Assert.Equal(wse.WebSocketErrorCode, error);
     Assert.NotEqual(wse.Message, "");
     Assert.Equal(wse.InnerException, inner);
 }

 public WebSocketException(WebSocketError error, int nativeError)
     : this(error, nativeError, GetErrorMessage(error))
 {
 }

 private static string GetErrorMessage(WebSocketError error)
 {
     // provide a canned message for the error type
     switch (error)
     {
         case WebSocketError.InvalidMessageType:
             return SR.GetString(SR.net_WebSockets_InvalidMessageType_Generic,
                 typeof(WebSocket).Name + WebSocketBase.Methods.CloseAsync,
                 typeof(WebSocket).Name + WebSocketBase.Methods.CloseOutputAsync);
         case WebSocketError.Faulted:
             return SR.GetString(SR.net_Websockets_WebSocketBaseFaulted);
         case WebSocketError.NotAWebSocket:
             return SR.GetString(SR.net_WebSockets_NotAWebSocket_Generic);
         case WebSocketError.UnsupportedVersion:
             return SR.GetString(SR.net_WebSockets_UnsupportedWebSocketVersion_Generic);
         case WebSocketError.UnsupportedProtocol:
             return SR.GetString(SR.net_WebSockets_UnsupportedProtocol_Generic);
         case WebSocketError.HeaderError:
             return SR.GetString(SR.net_WebSockets_HeaderError_Generic);
         case WebSocketError.ConnectionClosedPrematurely:
             return SR.GetString(SR.net_WebSockets_ConnectionClosedPrematurely_Generic);
         case WebSocketError.InvalidState:
             return SR.GetString(SR.net_WebSockets_InvalidState_Generic);
         default:
             return SR.GetString(SR.net_WebSockets_Generic);
     }
 }

 public void ConstructorTests_WebSocketError_NativeError_Message_Exception_Success(int nativeError, WebSocketError error, int expectedHResult)
 {
     const string Message = "Message";
     var inner = new Exception();
     var wse = new WebSocketException(error, nativeError, Message, inner);
     Assert.Equal(expectedHResult, wse.HResult);
     Assert.Equal(error, wse.WebSocketErrorCode);
     Assert.Equal(Message, wse.Message);
     Assert.Same(inner, wse.InnerException);
 }

 private static string GetErrorMessage(WebSocketError error)
 {
     // Provide a canned message for the error type.
     switch (error)
     {
         case WebSocketError.InvalidMessageType:
             return SR.Format(SR.net_WebSockets_InvalidMessageType_Generic,
                 $"{nameof(WebSocket)}.{nameof(WebSocket.CloseAsync)}",
                 $"{nameof(WebSocket)}.{nameof(WebSocket.CloseOutputAsync)}");
         case WebSocketError.Faulted:
             return SR.net_Websockets_WebSocketBaseFaulted;
         case WebSocketError.NotAWebSocket:
             return SR.net_WebSockets_NotAWebSocket_Generic;
         case WebSocketError.UnsupportedVersion:
             return SR.net_WebSockets_UnsupportedWebSocketVersion_Generic;
         case WebSocketError.UnsupportedProtocol:
             return SR.net_WebSockets_UnsupportedProtocol_Generic;
         case WebSocketError.HeaderError:
             return SR.net_WebSockets_HeaderError_Generic;
         case WebSocketError.ConnectionClosedPrematurely:
             return SR.net_WebSockets_ConnectionClosedPrematurely_Generic;
         case WebSocketError.InvalidState:
             return SR.net_WebSockets_InvalidState_Generic;
         default:
             return SR.net_WebSockets_Generic;
     }
 }

		void AssertWebSocketException (AggregateException e, WebSocketError error, Type inner = null)
		{
			var wsEx = e.InnerException as WebSocketException;
			Console.WriteLine (e.InnerException.ToString ());
			Assert.IsNotNull (wsEx, "Not a websocketexception");
			Assert.AreEqual (error, wsEx.WebSocketErrorCode);
			if (inner != null) {
				Assert.IsNotNull (wsEx.InnerException);
				Assert.IsTrue (inner.IsInstanceOfType (wsEx.InnerException));
			}
		}

        /// <summary>Send a close message to the server and throw an exception, in response to getting bad data from the server.</summary>
        /// <param name="closeStatus">The close status code to use.</param>
        /// <param name="error">The error reason.</param>
        /// <param name="cancellationToken">The CancellationToken used to cancel the websocket.</param>
        /// <param name="innerException">An optional inner exception to include in the thrown exception.</param>
        private async Task CloseWithReceiveErrorAndThrowAsync(
            WebSocketCloseStatus closeStatus, WebSocketError error, CancellationToken cancellationToken, Exception innerException = null)
        {
            // Close the connection if it hasn't already been closed
            if (!_sentCloseFrame)
            {
                await CloseOutputAsync(closeStatus, string.Empty, cancellationToken).ConfigureAwait(false);
            }

            // Dump our receive buffer; we're in a bad state to do any further processing
            _receiveBufferCount = 0;

            // Let the caller know we've failed
            throw new WebSocketException(error, innerException);
        }