Merge | SqlCommand Execute Reader

src/Microsoft.Data.SqlClient/netcore/src/Microsoft/Data/SqlClient/SqlCommand.netcore.cs

@@ -2733,69 +2733,6 @@ private void ReadDescribeEncryptionParameterResults(
             }
         }
 
-        private SqlDataReader RunExecuteReaderTdsWithTransparentParameterEncryption(
-            CommandBehavior cmdBehavior,
-            RunBehavior runBehavior,
-            bool returnStream,
-            bool isAsync,
-            int timeout,
-            out Task task,
-            bool asyncWrite,
-            bool isRetry,
-            SqlDataReader ds = null,
-            Task describeParameterEncryptionTask = null)
-        {
-            Debug.Assert(!asyncWrite || isAsync, "AsyncWrite should be always accompanied by Async");
-
-            if (ds == null && returnStream)
-            {
-                ds = new SqlDataReader(this, cmdBehavior);
-            }
-
-            if (describeParameterEncryptionTask != null)
-            {
-                long parameterEncryptionStart = ADP.TimerCurrent();
-                TaskCompletionSource<object> completion = new TaskCompletionSource<object>();
-                AsyncHelper.ContinueTaskWithState(describeParameterEncryptionTask, completion, this,
-                    (object state) =>
-                    {
-                        SqlCommand command = (SqlCommand)state;
-                        Task subTask = null;
-                        command.GenerateEnclavePackage();
-                        command.RunExecuteReaderTds(cmdBehavior, runBehavior, returnStream, isAsync, TdsParserStaticMethods.GetRemainingTimeout(timeout, parameterEncryptionStart), out subTask, asyncWrite, isRetry, ds);
-                        if (subTask == null)
-                        {
-                            completion.SetResult(null);
-                        }
-                        else
-                        {
-                            AsyncHelper.ContinueTaskWithState(subTask, completion, completion, static (object state) => ((TaskCompletionSource<object>)state).SetResult(null));
-                        }
-                    },
-                    onFailure: static (Exception exception, object state) =>
-                    {
-                        ((SqlCommand)state).CachedAsyncState?.ResetAsyncState();
-                        if (exception != null)
-                        {
-                            throw exception;
-                        }
-                    },
-                    onCancellation: static (object state) =>
-                    {
-                        ((SqlCommand)state).CachedAsyncState?.ResetAsyncState();
-                    }
-                );
-                task = completion.Task;
-                return ds;
-            }
-            else
-            {
-                // Synchronous execution.
-                GenerateEnclavePackage();
-                return RunExecuteReaderTds(cmdBehavior, runBehavior, returnStream, isAsync, timeout, out task, asyncWrite, isRetry, ds);
-            }
-        }
-
         private void GenerateEnclavePackage()
         {
             if (keysToBeSentToEnclave == null || keysToBeSentToEnclave.Count <= 0)

src/Microsoft.Data.SqlClient/netfx/src/Microsoft/Data/SqlClient/SqlCommand.netfx.cs

@@ -2689,67 +2689,6 @@ private void ReadDescribeEncryptionParameterResults(
             }
         }
 
-        private SqlDataReader RunExecuteReaderTdsWithTransparentParameterEncryption(
-            CommandBehavior cmdBehavior,
-            RunBehavior runBehavior,
-            bool returnStream,
-            bool isAsync,
-            int timeout,
-            out Task task,
-            bool asyncWrite,
-            bool isRetry,
-            SqlDataReader ds = null,
-            Task describeParameterEncryptionTask = null)
-        {
-            Debug.Assert(!asyncWrite || isAsync, "AsyncWrite should be always accompanied by Async");
-
-            if (ds == null && returnStream)
-            {
-                ds = new SqlDataReader(this, cmdBehavior);
-            }
-
-            if (describeParameterEncryptionTask != null)
-            {
-                long parameterEncryptionStart = ADP.TimerCurrent();
-                TaskCompletionSource<object> completion = new TaskCompletionSource<object>();
-                AsyncHelper.ContinueTaskWithState(describeParameterEncryptionTask, completion, this,
-                    (object state) =>
-                    {
-                        SqlCommand command = (SqlCommand)state;
-                        Task subTask = null;
-                        command.GenerateEnclavePackage();
-                        command.RunExecuteReaderTds(cmdBehavior, runBehavior, returnStream, isAsync, TdsParserStaticMethods.GetRemainingTimeout(timeout, parameterEncryptionStart), out subTask, asyncWrite, isRetry, ds);
-                        if (subTask == null)
-                        {
-                            completion.SetResult(null);
-                        }
-                        else
-                        {
-                            AsyncHelper.ContinueTaskWithState(subTask, completion, completion, static (object state2) => ((TaskCompletionSource<object>)state2).SetResult(null));
-                        }
-                    },
-                    onFailure: static (Exception exception, object state) =>
-                    {
-                        ((SqlCommand)state).CachedAsyncState?.ResetAsyncState();
-                        if (exception != null)
-                        {
-                            throw exception;
-                        }
-                    },
-                    onCancellation: static (object state) => ((SqlCommand)state).CachedAsyncState?.ResetAsyncState(),
-                    connectionToDoom: null,
-                    connectionToAbort: _activeConnection);
-                task = completion.Task;
-                return ds;
-            }
-            else
-            {
-                // Synchronous execution.
-                GenerateEnclavePackage();
-                return RunExecuteReaderTds(cmdBehavior, runBehavior, returnStream, isAsync, timeout, out task, asyncWrite, isRetry, ds);
-            }
-        }
-
         private void GenerateEnclavePackage()
         {
             if (keysToBeSentToEnclave == null || keysToBeSentToEnclave.Count <= 0)

src/Microsoft.Data.SqlClient/src/Microsoft/Data/SqlClient/SqlCommand.Reader.cs

@@ -747,6 +747,99 @@ private void RunExecuteReaderTdsSetupReconnectContinuation(
                 });
         }
 
+        private SqlDataReader RunExecuteReaderTdsWithTransparentParameterEncryption(
+            CommandBehavior cmdBehavior,
+            RunBehavior runBehavior,
+            bool returnStream,
+            bool isAsync,
+            int timeout,
+            out Task task,
+            bool asyncWrite,
+            bool isRetry,
+            SqlDataReader ds = null,
+            Task describeParameterEncryptionTask = null) // @TODO: This task should likely come from this method otherwise this is just setting up a continuation
+        {
+            Debug.Assert(!asyncWrite || isAsync, "AsyncWrite should be always accompanied by Async");
+
+            if (ds is null && returnStream)
+            {
+                ds = new SqlDataReader(command: this, cmdBehavior);
+            }
+
+            if (describeParameterEncryptionTask is not null)
+            {
+                // @TODO: I guess this means async execution? Using tasks as the primary means of determining async vs sync is clunky. It would be better to have separate async vs sync pathways.
+                long parameterEncryptionStart = ADP.TimerCurrent();
+
+                // @TODO: This can totally be a non-generic TCS
+                // @TODO: This is a prime candidate for proper async-await execution
+                TaskCompletionSource<object> completion = new TaskCompletionSource<object>();
+                AsyncHelper.ContinueTaskWithState(
+                    task: describeParameterEncryptionTask,
+                    completion: completion,
+                    state: this,
+                    onSuccess: state =>
+                    {
+                        SqlCommand command = (SqlCommand)state;
+                        command.GenerateEnclavePackage();
+                        command.RunExecuteReaderTds(
+                            cmdBehavior,
+                            runBehavior,
+                            returnStream,
+                            isAsync,
+                            TdsParserStaticMethods.GetRemainingTimeout(timeout, parameterEncryptionStart),
+                            out Task subTask,
+                            asyncWrite,
+                            isRetry,
+                            ds);
+
+                        if (subTask is null)
+                        {
+                            // @TODO: Why would this ever be the case? We should structure this so that it doesn't need to be checked.
+                            completion.SetResult(null);
+                        }
+                        else
+                        {
+                            AsyncHelper.ContinueTaskWithState(
+                                task: subTask,
+                                completion: completion,
+                                state: completion,
+                                onSuccess: static state => ((TaskCompletionSource<object>)state).SetResult(null));
+                        }
+                    },
+                    onFailure: static (exception, state) =>
+                    {
+                        ((SqlCommand)state).CachedAsyncState?.ResetAsyncState();
+                        if (exception is not null)
+                        {
+                            throw exception;
+                        }
+                    },
+                    onCancellation: static state =>
+                    {
+                        ((SqlCommand)state).CachedAsyncState?.ResetAsyncState();
+                    });
+
+                task = completion.Task;
+                return ds;
+            }
+            else
+            {
+                // Synchronous execution
+                GenerateEnclavePackage();
+                return RunExecuteReaderTds(
+                    cmdBehavior,
+                    runBehavior,
+                    returnStream,
+                    isAsync,
+                    timeout,
+                    out task,
+                    asyncWrite,
+                    isRetry,
+                    ds);
+            }
+        }
+
         private SqlDataReader RunExecuteReaderWithRetry(
             CommandBehavior cmdBehavior,
             RunBehavior runBehavior,