|
static private ValidateArraySegment ( ArraySegment |
||
| arraySegment | ArraySegment |
|
| parameterName | string | |
| return | void | |
public Task <WebSocketReceiveResult> ReceiveAsync(
ArraySegment <byte> buffer,
CancellationToken cancellationToken)
{
WebSocketValidate.ValidateArraySegment(buffer, nameof(buffer));
return(_webSocket.ReceiveAsync(buffer, cancellationToken));
}
public override Task <WebSocketReceiveResult> ReceiveAsync(ArraySegment <byte> buffer,
CancellationToken cancellationToken)
{
ThrowIfNotConnected();
WebSocketValidate.ValidateArraySegment <byte>(buffer, "buffer");
return(_innerWebSocket.ReceiveAsync(buffer, cancellationToken));
}
public override Task SendAsync(ArraySegment <byte> buffer, WebSocketMessageType messageType, bool endOfMessage, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
ThrowIfDisposed();
// fast check of previous _state instead of GetReadyState(), the readyState would be validated on JS side
if (_state != WebSocketState.Open)
{
throw new InvalidOperationException(SR.net_WebSockets_NotConnected);
}
if (messageType != WebSocketMessageType.Binary && messageType != WebSocketMessageType.Text)
{
throw new ArgumentException(SR.Format(SR.net_WebSockets_Argument_InvalidMessageType,
messageType,
nameof(SendAsync),
WebSocketMessageType.Binary,
WebSocketMessageType.Text,
nameof(CloseOutputAsync)),
nameof(messageType));
}
WebSocketValidate.ValidateArraySegment(buffer, nameof(buffer));
return(SendAsyncCore(buffer, messageType, endOfMessage, cancellationToken));
}
internal static Task <HttpListenerWebSocketContext> AcceptWebSocketAsync(HttpListenerContext context,
string subProtocol,
int receiveBufferSize,
TimeSpan keepAliveInterval,
ArraySegment <byte> internalBuffer)
{
ValidateOptions(subProtocol, receiveBufferSize, MinSendBufferSize, keepAliveInterval);
WebSocketValidate.ValidateArraySegment(internalBuffer, nameof(internalBuffer));
WebSocketBuffer.Validate(internalBuffer.Count, receiveBufferSize, MinSendBufferSize, true);
return(AcceptWebSocketAsyncCore(context, subProtocol, receiveBufferSize, keepAliveInterval, internalBuffer));
}
public override Task <WebSocketReceiveResult> ReceiveAsync(ArraySegment <byte> buffer, CancellationToken cancellationToken)
{
if (cancellationToken.IsCancellationRequested)
{
return(Task.FromException <WebSocketReceiveResult>(new OperationCanceledException(cancellationToken)));
}
ThrowIfDisposed();
// fast check of previous _state instead of GetReadyState(), the readyState would be validated on JS side
if (_state != WebSocketState.Open && _state != WebSocketState.CloseSent)
{
throw new WebSocketException(WebSocketError.InvalidState, SR.Format(SR.net_WebSockets_InvalidState, _state, "Open, CloseSent"));
}
WebSocketValidate.ValidateArraySegment(buffer, nameof(buffer));
return(ReceiveAsyncCore(buffer, cancellationToken));
}
public override Task SendAsync(ArraySegment <byte> buffer, WebSocketMessageType messageType, bool endOfMessage,
CancellationToken cancellationToken)
{
ThrowIfNotConnected();
if (!((messageType == WebSocketMessageType.Text) || (messageType == WebSocketMessageType.Binary)))
{
string errorMessage = SR.Format(
SR.net_WebSockets_Argument_InvalidMessageType,
"Close",
"SendAsync",
"Binary",
"Text",
"CloseOutputAsync");
throw new ArgumentException(errorMessage, nameof(messageType));
}
WebSocketValidate.ValidateArraySegment <byte>(buffer, "buffer");
return(_innerWebSocket.SendAsync(buffer, messageType, endOfMessage, cancellationToken));
}
public Task SendAsync(
ArraySegment <byte> buffer,
WebSocketMessageType messageType,
bool endOfMessage,
CancellationToken cancellationToken)
{
if (messageType != WebSocketMessageType.Text && messageType != WebSocketMessageType.Binary)
{
string errorMessage = SR.Format(
SR.net_WebSockets_Argument_InvalidMessageType,
nameof(WebSocketMessageType.Close),
nameof(SendAsync),
nameof(WebSocketMessageType.Binary),
nameof(WebSocketMessageType.Text),
nameof(CloseOutputAsync));
throw new ArgumentException(errorMessage, nameof(messageType));
}
WebSocketValidate.ValidateArraySegment(buffer, nameof(buffer));
return(_webSocket.SendAsync(buffer, messageType, endOfMessage, cancellationToken));
}
internal static WebSocket Create(Stream innerStream,
string subProtocol,
int receiveBufferSize,
TimeSpan keepAliveInterval,
ArraySegment <byte> internalBuffer)
{
if (!WebSocketProtocolComponent.IsSupported)
{
WebSocketValidate.ThrowPlatformNotSupportedException_WSPC();
}
WebSocketValidate.ValidateInnerStream(innerStream);
WebSocketValidate.ValidateOptions(subProtocol, receiveBufferSize, WebSocketBuffer.MinSendBufferSize, keepAliveInterval);
WebSocketValidate.ValidateArraySegment <byte>(internalBuffer, nameof(internalBuffer));
WebSocketBuffer.Validate(internalBuffer.Count, receiveBufferSize, WebSocketBuffer.MinSendBufferSize, true);
return(new ServerWebSocket(innerStream,
subProtocol,
receiveBufferSize,
keepAliveInterval,
internalBuffer));
}
public void SetBuffer(int receiveBufferSize, int sendBufferSize, ArraySegment <byte> buffer)
{
ThrowIfReadOnly();
if (receiveBufferSize <= 0)
{
throw new ArgumentOutOfRangeException(nameof(receiveBufferSize), receiveBufferSize, SR.Format(SR.net_WebSockets_ArgumentOutOfRange_TooSmall, 1));
}
if (sendBufferSize <= 0)
{
throw new ArgumentOutOfRangeException(nameof(sendBufferSize), sendBufferSize, SR.Format(SR.net_WebSockets_ArgumentOutOfRange_TooSmall, 1));
}
WebSocketValidate.ValidateArraySegment(buffer, nameof(buffer));
if (buffer.Count == 0)
{
throw new ArgumentOutOfRangeException(nameof(buffer));
}
_receiveBufferSize = receiveBufferSize;
_sendBufferSize = sendBufferSize;
_buffer = buffer;
}
