ConnectAsync()

async Task System.Net.WebSockets.WebSocketHandle.ConnectAsync ( Uri uri, CancellationToken cancellationToken, ClientWebSocketOptions options )

inline

Definition at line 76 of file WebSocketHandle.cs.

    {
        HttpResponseMessage response = null;
        SocketsHttpHandler handler = null;
        bool disposeHandler = true;
        try
        {
            HttpRequestMessage httpRequestMessage = new HttpRequestMessage(HttpMethod.Get, uri);
            WebHeaderCollection requestHeaders = options._requestHeaders;
            if (requestHeaders != null && requestHeaders.Count > 0)
            {
                foreach (string requestHeader in options.RequestHeaders)
                {
                    httpRequestMessage.Headers.TryAddWithoutValidation(requestHeader, options.RequestHeaders[requestHeader]);
                }
            }
            KeyValuePair<string, string> secKeyAndSecWebSocketAccept = CreateSecKeyAndSecWebSocketAccept();
            AddWebSocketHeaders(httpRequestMessage, secKeyAndSecWebSocketAccept.Key, options);
            if (options.Credentials == null && !options.UseDefaultCredentials && options.Proxy == null && options.Cookies == null && options.RemoteCertificateValidationCallback == null)
            {
                X509CertificateCollection clientCertificates = options._clientCertificates;
                if (clientCertificates != null && clientCertificates.Count == 0)
                {
                    disposeHandler = false;
                    handler = s_defaultHandler;
                    if (handler == null)
                    {
                        handler = new SocketsHttpHandler
                        {
                            PooledConnectionLifetime = TimeSpan.Zero,
                            UseProxy = false,
                            UseCookies = false
                        };
                        if (Interlocked.CompareExchange(ref s_defaultHandler, handler, null) != null)
                        {
                            handler.Dispose();
                            handler = s_defaultHandler;
                        }
                    }
                    goto IL_02ee;
                }
            }
            handler = new SocketsHttpHandler
            {
                PooledConnectionLifetime = TimeSpan.Zero,
                CookieContainer = options.Cookies,
                UseCookies = (options.Cookies != null),
                SslOptions = 
                {
                    RemoteCertificateValidationCallback = options.RemoteCertificateValidationCallback
                }
            };
            if (options.UseDefaultCredentials)
            {
                handler.Credentials = CredentialCache.DefaultCredentials;
            }
            else
            {
                handler.Credentials = options.Credentials;
            }
            if (options.Proxy == null)
            {
                handler.UseProxy = false;
            }
            else if (options.Proxy != DefaultWebProxy.Instance)
            {
                handler.Proxy = options.Proxy;
            }
            X509CertificateCollection clientCertificates2 = options._clientCertificates;
            if (clientCertificates2 != null && clientCertificates2.Count > 0)
            {
                handler.SslOptions.ClientCertificates = new X509Certificate2Collection();
                handler.SslOptions.ClientCertificates.AddRange(options.ClientCertificates);
            }
            goto IL_02ee;
            IL_02ee:
            CancellationTokenSource externalAndAbortCancellation;
            CancellationTokenSource cancellationTokenSource2;
            if (cancellationToken.CanBeCanceled)
            {
                CancellationTokenSource cancellationTokenSource;
                externalAndAbortCancellation = (cancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, _abortSource.Token));
                cancellationTokenSource2 = cancellationTokenSource;
            }
            else
            {
                cancellationTokenSource2 = null;
                externalAndAbortCancellation = _abortSource;
            }
            using (cancellationTokenSource2)
            {
                response = await new HttpMessageInvoker(handler).SendAsync(httpRequestMessage, externalAndAbortCancellation.Token).ConfigureAwait(continueOnCapturedContext: false);
                externalAndAbortCancellation.Token.ThrowIfCancellationRequested();
            }
            if (response.StatusCode != HttpStatusCode.SwitchingProtocols)
            {
                throw new WebSocketException(WebSocketError.NotAWebSocket, System.SR.Format(System.SR.net_WebSockets_Connect101Expected, (int)response.StatusCode));
            }
            ValidateHeader(response.Headers, "Connection", "Upgrade");
            ValidateHeader(response.Headers, "Upgrade", "websocket");
            ValidateHeader(response.Headers, "Sec-WebSocket-Accept", secKeyAndSecWebSocketAccept.Value);
            string text = null;
            if (response.Headers.TryGetValues("Sec-WebSocket-Protocol", out IEnumerable<string> values))
            {
                string[] array = (string[])values;
                if (array.Length != 0 && !string.IsNullOrEmpty(array[0]))
                {
                    if (options._requestedSubProtocols != null)
                    {
                        foreach (string requestedSubProtocol in options._requestedSubProtocols)
                        {
                            if (requestedSubProtocol.Equals(array[0], StringComparison.OrdinalIgnoreCase))
                            {
                                text = requestedSubProtocol;
                                break;
                            }
                        }
                    }
                    if (text == null)
                    {
                        throw new WebSocketException(WebSocketError.UnsupportedProtocol, System.SR.Format(System.SR.net_WebSockets_AcceptUnsupportedProtocol, string.Join(", ", options.RequestedSubProtocols), string.Join(", ", array)));
                    }
                }
            }
            WebSocketDeflateOptions webSocketDeflateOptions = null;
            if (options.DangerousDeflateOptions != null && response.Headers.TryGetValues("Sec-WebSocket-Extensions", out IEnumerable<string> values2))
            {
                foreach (string item in values2)
                {
                    ReadOnlySpan<char> readOnlySpan = item;
                    if (readOnlySpan.TrimStart().StartsWith("permessage-deflate"))
                    {
                        webSocketDeflateOptions = ParseDeflateOptions(readOnlySpan, options.DangerousDeflateOptions);
                        break;
                    }
                }
            }
            if (response.Content == null)
            {
                throw new WebSocketException(WebSocketError.ConnectionClosedPrematurely);
            }
            Stream stream = response.Content.ReadAsStream();
            WebSocket = WebSocket.CreateFromStream(stream, new WebSocketCreationOptions
            {
                IsServer = false,
                SubProtocol = text,
                KeepAliveInterval = options.KeepAliveInterval,
                DangerousDeflateOptions = webSocketDeflateOptions
            });
            _negotiatedDeflateOptions = webSocketDeflateOptions;
        }
        catch (Exception ex)
        {
            if (_state < WebSocketState.Closed)
            {
                _state = WebSocketState.Closed;
            }
            Abort();
            response?.Dispose();
            if (ex is WebSocketException || (ex is OperationCanceledException && cancellationToken.IsCancellationRequested))
            {
                throw;
            }
            throw new WebSocketException(WebSocketError.Faulted, System.SR.net_webstatus_ConnectFailure, ex);
        }
        finally
        {
            if (disposeHandler)
            {
                handler?.Dispose();
            }
        }
    }

References System.Net.WebSockets.WebSocketHandle._abortSource, System.Net.WebSockets.WebSocketHandle._negotiatedDeflateOptions, System.Net.WebSockets.WebSocketHandle._state, System.Net.WebSockets.WebSocketHandle.Abort(), System.Net.WebSockets.WebSocketHandle.AddWebSocketHeaders(), System.array, System.cancellationToken, System.Threading.Interlocked.CompareExchange(), System.Collections.Generic.Dictionary< TKey, TValue >.Count, System.Net.WebSockets.WebSocket.CreateFromStream(), System.Threading.CancellationTokenSource.CreateLinkedTokenSource(), System.Net.WebSockets.WebSocketHandle.CreateSecKeyAndSecWebSocketAccept(), System.Net.CredentialCache.DefaultCredentials, System.Net.Http.SocketsHttpHandler.Dispose(), System.SR.Format(), System.Net.Http.HttpMethod.Get, System.Net.WebSockets.WebSocketHandle.DefaultWebProxy.Instance, System.item, System.Net.WebSockets.WebSocketCreationOptions.KeepAliveInterval, System.SR.net_WebSockets_AcceptUnsupportedProtocol, System.SR.net_WebSockets_Connect101Expected, System.SR.net_webstatus_ConnectFailure, System.options, System.Net.WebSockets.WebSocketHandle.ParseDeflateOptions(), System.Net.WebSockets.WebSocketHandle.s_defaultHandler, System.Net.Http.HttpMessageInvoker.SendAsync(), System.Net.Http.SocketsHttpHandler.SslOptions, System.stream, System.text, System.Threading.CancellationTokenSource.Token, System.Net.UseProxy, System.Net.WebSockets.WebSocketHandle.ValidateHeader(), System.values, and System.TimeSpan.Zero.

Referenced by System.Net.WebSockets.ClientWebSocket.ConnectAsyncCore().