public async Task SaveEndpointResponseToFileAsync()

in WindowsDevicePortalWrapper/WindowsDevicePortalWrapper.Shared/DevicePortal.cs [356:494]
119 lines of code
10 McCabe index (conditional complexity)

        public async Task SaveEndpointResponseToFileAsync(
            string endpoint,
            string directory,
            HttpMethods httpMethod,
            Stream requestBody = null,
            string requestBodyContentType = null)
        {
            Uri uri = new Uri(this.deviceConnection.Connection, endpoint);

            // Convert the OS version, such as 14385.1002.amd64fre.rs1_xbox_rel_1608.160709-1700, into a friendly OS version, such as rs1_xbox_rel_1608
            string friendlyOSVersion = this.OperatingSystemVersion;
            string[] versionParts = friendlyOSVersion.Split('.');
            if (versionParts.Length == ExpectedOSVersionSections)
            {
                friendlyOSVersion = versionParts[TargetOSVersionSection];
            }

            // Create the filename as DeviceFamily_OSVersion.dat, replacing '/', '.', and '-' with '_' so
            // we can create a class with the same name as this Device/OS pair for tests.
            string filename = endpoint + "_" + this.Platform.ToString() + "_" + friendlyOSVersion;

            if (httpMethod != HttpMethods.Get)
            {
                filename = httpMethod.ToString() + "_" + filename;
            }

            Utilities.ModifyEndpointForFilename(ref filename);

            filename += ".dat";
            string filepath = Path.Combine(directory, filename);

            if (HttpMethods.WebSocket == httpMethod)
            {
#if WINDOWS_UWP
                WebSocket<object> websocket = new WebSocket<object>(this.deviceConnection, true);
#else
                WebSocket<object> websocket = new WebSocket<object>(this.deviceConnection, this.ServerCertificateValidation, true);
#endif // WINDOWS_UWP

                ManualResetEvent streamReceived = new ManualResetEvent(false);
                Stream stream = null;

                WindowsDevicePortal.WebSocketStreamReceivedEventInternalHandler<object> streamReceivedHandler =
                    delegate(WebSocket<object> sender, WebSocketMessageReceivedEventArgs<Stream> args)
                {
                    if (args.Message != null)
                    {
                        stream = args.Message;
                        streamReceived.Set();
                    }
                };

                websocket.WebSocketStreamReceived += streamReceivedHandler;

                await websocket.ConnectAsync(endpoint);

                await websocket.ReceiveMessagesAsync();

                streamReceived.WaitOne();

                await websocket.CloseAsync();

                websocket.WebSocketStreamReceived -= streamReceivedHandler;

                using (stream)
                {
                    using (var fileStream = File.Create(filepath))
                    {
                        stream.Seek(0, SeekOrigin.Begin);
                        stream.CopyTo(fileStream);
                    }
                }
            }
            else if (HttpMethods.Put == httpMethod)
            {
#if WINDOWS_UWP
                HttpStreamContent streamContent = null;
#else
                StreamContent streamContent = null;
#endif // WINDOWS_UWP

                if (requestBody != null)
                {
#if WINDOWS_UWP
                streamContent = new HttpStreamContent(requestBody.AsInputStream());
                streamContent.Headers.ContentType = new HttpMediaTypeHeaderValue(requestBodyContentType);
#else
                    streamContent = new StreamContent(requestBody);
                    streamContent.Headers.ContentType = new MediaTypeHeaderValue(requestBodyContentType);
#endif // WINDOWS_UWP
                }

                using (Stream dataStream = await this.PutAsync(uri, streamContent))
                {
                    using (var fileStream = File.Create(filepath))
                    {
                        dataStream.Seek(0, SeekOrigin.Begin);
                        dataStream.CopyTo(fileStream);
                    }
                }
            }
            else if (HttpMethods.Post == httpMethod)
            {
                using (Stream dataStream = await this.PostAsync(uri, requestBody, requestBodyContentType))
                {
                    using (var fileStream = File.Create(filepath))
                    {
                        dataStream.Seek(0, SeekOrigin.Begin);
                        dataStream.CopyTo(fileStream);
                    }
                }
            }
            else if (HttpMethods.Delete == httpMethod)
            {
                using (Stream dataStream = await this.DeleteAsync(uri))
                {
                    using (var fileStream = File.Create(filepath))
                    {
                        dataStream.Seek(0, SeekOrigin.Begin);
                        dataStream.CopyTo(fileStream);
                    }
                }
            }
            else if (HttpMethods.Get == httpMethod)
            {
                using (Stream dataStream = await this.GetAsync(uri))
                {
                    using (var fileStream = File.Create(filepath))
                    {
                        dataStream.Seek(0, SeekOrigin.Begin);
                        dataStream.CopyTo(fileStream);
                    }
                }
            }
            else
            {
                throw new NotImplementedException(string.Format("Unsupported HttpMethod {0}", httpMethod.ToString()));
            }
        }