WebSocket.cs

using System.ComponentModel;
using System.IO;
using System.Runtime.Versioning;
using System.Threading;
using System.Threading.Tasks;

namespace System.Net.WebSockets
{
    public abstract class WebSocket : IDisposable
    {
        private static TimeSpan? defaultKeepAliveInterval;

        public abstract WebSocketCloseStatus? CloseStatus
        {
            get;
        }

        public abstract string CloseStatusDescription
        {
            get;
        }

        public abstract string SubProtocol
        {
            get;
        }

        public abstract WebSocketState State
        {
            get;
        }

        public static TimeSpan DefaultKeepAliveInterval
        {
            get
            {
                if (!defaultKeepAliveInterval.HasValue)
                {
                    if (WebSocketProtocolComponent.IsSupported)
                    {
                        defaultKeepAliveInterval = WebSocketProtocolComponent.WebSocketGetDefaultKeepAliveInterval();
                    }
                    else
                    {
                        defaultKeepAliveInterval = Timeout.InfiniteTimeSpan;
                    }
                }
                return defaultKeepAliveInterval.Value;
            }
        }

        public static ArraySegment<byte> CreateClientBuffer(int receiveBufferSize, int sendBufferSize)
        {
            WebSocketHelpers.ValidateBufferSizes(receiveBufferSize, sendBufferSize);
            return WebSocketBuffer.CreateInternalBufferArraySegment(receiveBufferSize, sendBufferSize, isServerBuffer: false);
        }

        public static ArraySegment<byte> CreateServerBuffer(int receiveBufferSize)
        {
            WebSocketHelpers.ValidateBufferSizes(receiveBufferSize, 16);
            return WebSocketBuffer.CreateInternalBufferArraySegment(receiveBufferSize, 16, isServerBuffer: true);
        }

        [EditorBrowsable(EditorBrowsableState.Never)]
        public static WebSocket CreateClientWebSocket(Stream innerStream, string subProtocol, int receiveBufferSize, int sendBufferSize, TimeSpan keepAliveInterval, bool useZeroMaskingKey, ArraySegment<byte> internalBuffer)
        {
            if (!WebSocketProtocolComponent.IsSupported)
            {
                WebSocketHelpers.ThrowPlatformNotSupportedException_WSPC();
            }
            WebSocketHelpers.ValidateInnerStream(innerStream);
            WebSocketHelpers.ValidateOptions(subProtocol, receiveBufferSize, sendBufferSize, keepAliveInterval);
            WebSocketHelpers.ValidateArraySegment(internalBuffer, "internalBuffer");
            WebSocketBuffer.Validate(internalBuffer.Count, receiveBufferSize, sendBufferSize, isServerBuffer: false);
            return new InternalClientWebSocket(innerStream, subProtocol, receiveBufferSize, sendBufferSize, keepAliveInterval, useZeroMaskingKey, internalBuffer);
        }

        internal static WebSocket CreateServerWebSocket(Stream innerStream, string subProtocol, int receiveBufferSize, TimeSpan keepAliveInterval, ArraySegment<byte> internalBuffer)
        {
            if (!WebSocketProtocolComponent.IsSupported)
            {
                WebSocketHelpers.ThrowPlatformNotSupportedException_WSPC();
            }
            WebSocketHelpers.ValidateInnerStream(innerStream);
            WebSocketHelpers.ValidateOptions(subProtocol, receiveBufferSize, 16, keepAliveInterval);
            WebSocketHelpers.ValidateArraySegment(internalBuffer, "internalBuffer");
            WebSocketBuffer.Validate(internalBuffer.Count, receiveBufferSize, 16, isServerBuffer: true);
            return new ServerWebSocket(innerStream, subProtocol, receiveBufferSize, keepAliveInterval, internalBuffer);
        }

        [EditorBrowsable(EditorBrowsableState.Never)]
        public static void RegisterPrefixes()
        {
            WebRequest.RegisterPrefix(Uri.UriSchemeWs + ":", new WebSocketHttpRequestCreator(usingHttps: false));
            WebRequest.RegisterPrefix(Uri.UriSchemeWss + ":", new WebSocketHttpRequestCreator(usingHttps: true));
        }

        [EditorBrowsable(EditorBrowsableState.Never)]
        [Obsolete("This API supports the .NET Framework infrastructure and is not intended to be used directly from your code.")]
        public static bool IsApplicationTargeting45()
        {
            return BinaryCompatibility.TargetsAtLeast_Desktop_V4_5;
        }

        public abstract void Abort();

        public abstract Task CloseAsync(WebSocketCloseStatus closeStatus, string statusDescription, CancellationToken cancellationToken);

        public abstract Task CloseOutputAsync(WebSocketCloseStatus closeStatus, string statusDescription, CancellationToken cancellationToken);

        public abstract void Dispose();

        public abstract Task<WebSocketReceiveResult> ReceiveAsync(ArraySegment<byte> buffer, CancellationToken cancellationToken);

        public abstract Task SendAsync(ArraySegment<byte> buffer, WebSocketMessageType messageType, bool endOfMessage, CancellationToken cancellationToken);

        protected static void ThrowOnInvalidState(WebSocketState state, params WebSocketState[] validStates)
        {
            string text = string.Empty;
            if (validStates != null && validStates.Length != 0)
            {
                foreach (WebSocketState webSocketState in validStates)
                {
                    if (state == webSocketState)
                    {
                        return;
                    }
                }
                text = string.Join(", ", validStates);
            }
            throw new WebSocketException(SR.GetString("net_WebSockets_InvalidState", state, text));
        }

        protected static bool IsStateTerminal(WebSocketState state)
        {
            if (state != WebSocketState.Closed)
            {
                return state == WebSocketState.Aborted;
            }
            return true;
        }
    }
}