Change existing async helper calls in SqlCommand

Author: benrr101

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

@@ -253,23 +253,22 @@ private SqlDataReader GetParameterEncryptionDataReader(
             bool isRetry)
         {
             returnTask = AsyncHelper.CreateContinuationTaskWithState(
-                task: fetchInputParameterEncryptionInfoTask,
+                taskToContinue: fetchInputParameterEncryptionInfoTask,
                 state: this,
-                onSuccess: state =>
+                onSuccess: sqlCommand =>
                 {
-                    SqlCommand command = (SqlCommand)state;
                     bool processFinallyBlockAsync = true;
                     bool decrementAsyncCountInFinallyBlockAsync = true;
 
                     try
                     {
                         // Check for any exceptions on network write, before reading.
-                        command.CheckThrowSNIException();
+                        sqlCommand.CheckThrowSNIException();
 
                         // If it is async, then TryFetchInputParameterEncryptionInfo ->
                         // RunExecuteReaderTds would have incremented the async count. Decrement it
                         // when we are about to complete async execute reader.
-                        SqlConnectionInternal internalConnectionTds = command._activeConnection.GetOpenTdsConnection();
+                        SqlConnectionInternal internalConnectionTds = sqlCommand._activeConnection.GetOpenTdsConnection();
                         if (internalConnectionTds is not null)
                         {
                             internalConnectionTds.DecrementAsyncCount();
@@ -278,13 +277,13 @@ private SqlDataReader GetParameterEncryptionDataReader(
 
                         // Complete executereader.
                         // @TODO: If we can remove this reference, this could be a static lambda
-                        describeParameterEncryptionDataReader = command.CompleteAsyncExecuteReader(
+                        describeParameterEncryptionDataReader = sqlCommand.CompleteAsyncExecuteReader(
                             isInternal: false,
                             forDescribeParameterEncryption: true);
-                        Debug.Assert(command._stateObj is null, "non-null state object in PrepareForTransparentEncryption.");
+                        Debug.Assert(sqlCommand._stateObj is null, "non-null state object in PrepareForTransparentEncryption.");
 
                         // Read the results of describe parameter encryption.
-                        command.ReadDescribeEncryptionParameterResults(
+                        sqlCommand.ReadDescribeEncryptionParameterResults(
                             describeParameterEncryptionDataReader,
                             describeParameterEncryptionRpcOriginalRpcMap,
                             isRetry);
@@ -304,7 +303,7 @@ private SqlDataReader GetParameterEncryptionDataReader(
                     }
                     finally
                     {
-                        command.PrepareTransparentEncryptionFinallyBlock(
+                        sqlCommand.PrepareTransparentEncryptionFinallyBlock(
                             closeDataReader: processFinallyBlockAsync,
                             decrementAsyncCount: decrementAsyncCountInFinallyBlockAsync,
                             clearDataStructures: processFinallyBlockAsync,
@@ -313,11 +312,9 @@ private SqlDataReader GetParameterEncryptionDataReader(
                             describeParameterEncryptionDataReader: describeParameterEncryptionDataReader);
                     }
                 },
-                onFailure: static (exception, state) =>
+                onFailure: static (sqlCommand, exception) =>
                 {
-                    SqlCommand command = (SqlCommand)state;
-                    command.CachedAsyncState?.ResetAsyncState();
-
+                    sqlCommand.CachedAsyncState?.ResetAsyncState();
                     if (exception is not null)
                     {
                         throw exception;

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

@@ -223,13 +223,13 @@ private IAsyncResult BeginExecuteNonQueryInternal(
                     if (execNonQuery is not null)
                     {
                         AsyncHelper.ContinueTaskWithState(
-                            task: execNonQuery,
-                            completion: localCompletion,
-                            state: Tuple.Create(this, localCompletion),
-                            onSuccess: static state =>
+                            taskToContinue: execNonQuery,
+                            taskCompletionSource: localCompletion,
+                            state1: this,
+                            state2: localCompletion,
+                            onSuccess: static (sqlCommand, localCompletion) =>
                             {
-                                var parameters = (Tuple<SqlCommand, TaskCompletionSource<object>>)state;
-                                parameters.Item1.BeginExecuteNonQueryInternalReadStage(parameters.Item2);
+                                sqlCommand.BeginExecuteNonQueryInternalReadStage(localCompletion);
                             });
                     }
                     else

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

@@ -1599,18 +1599,18 @@ private Task RunExecuteReaderTdsSetupContinuation(
         {
             // @TODO: Why use the state version if we can't make this a static helper?
             return AsyncHelper.CreateContinuationTaskWithState(
-                task: writeTask,
+                taskToContinue: writeTask,
                 state: _activeConnection,
-                onSuccess: state =>
+                onSuccess: sqlConnection =>
                 {
                     // This will throw if the connection is closed.
                     // @TODO: So... can we have something that specifically does that?
-                    ((SqlConnection)state).GetOpenTdsConnection();
+                    sqlConnection.GetOpenTdsConnection();
                     CachedAsyncState.SetAsyncReaderState(ds, runBehavior, optionSettings);
                 },
-                onFailure: static (exception, state) =>
+                onFailure: static (sqlConnection, _) =>
                 {
-                    ((SqlConnection)state).GetOpenTdsConnection().DecrementAsyncCount();
+                    sqlConnection.GetOpenTdsConnection().DecrementAsyncCount();
                 });
         }
 
@@ -1632,7 +1632,7 @@ private void RunExecuteReaderTdsSetupReconnectContinuation(
             AsyncHelper.SetTimeoutException(
                 completion,
                 timeout,
-                onFailure: static () => SQL.CR_ReconnectTimeout(),
+                onTimeout: static () => SQL.CR_ReconnectTimeout(),
                 timeoutCts.Token);
 
             // @TODO: With an object to pass around we can use the state-based version
@@ -1703,14 +1703,13 @@ private SqlDataReader RunExecuteReaderTdsWithTransparentParameterEncryption(
                 // @TODO: This is a prime candidate for proper async-await execution
                 TaskCompletionSource<object> completion = new TaskCompletionSource<object>();
                 AsyncHelper.ContinueTaskWithState(
-                    task: describeParameterEncryptionTask,
-                    completion: completion,
+                    taskToContinue: describeParameterEncryptionTask,
+                    taskCompletionSource: completion,
                     state: this,
-                    onSuccess: state =>
+                    onSuccess: sqlCommand =>
                     {
-                        SqlCommand command = (SqlCommand)state;
-                        command.GenerateEnclavePackage();
-                        command.RunExecuteReaderTds(
+                        sqlCommand.GenerateEnclavePackage();
+                        sqlCommand.RunExecuteReaderTds(
                             cmdBehavior,
                             runBehavior,
                             returnStream,
@@ -1729,23 +1728,23 @@ private SqlDataReader RunExecuteReaderTdsWithTransparentParameterEncryption(
                         else
                         {
                             AsyncHelper.ContinueTaskWithState(
-                                task: subTask,
-                                completion: completion,
+                                taskToContinue: subTask,
+                                taskCompletionSource: completion,
                                 state: completion,
-                                onSuccess: static state => ((TaskCompletionSource<object>)state).SetResult(null));
+                                onSuccess: static state => state.SetResult(null));
                         }
                     },
-                    onFailure: static (exception, state) =>
+                    onFailure: static (sqlCommand, exception) =>
                     {
-                        ((SqlCommand)state).CachedAsyncState?.ResetAsyncState();
+                        sqlCommand.CachedAsyncState?.ResetAsyncState();
                         if (exception is not null)
                         {
                             throw exception;
                         }
                     },
-                    onCancellation: static state =>
+                    onCancellation: static sqlCommand =>
                     {
-                        ((SqlCommand)state).CachedAsyncState?.ResetAsyncState();
+                        sqlCommand.CachedAsyncState?.ResetAsyncState();
                     });
 
                 task = completion.Task;

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

@@ -262,8 +262,8 @@ private IAsyncResult BeginExecuteXmlReaderInternal(
                 if (writeTask is not null)
                 {
                     AsyncHelper.ContinueTaskWithState(
-                        task: writeTask,
-                        completion: localCompletion,
+                        taskToContinue: writeTask,
+                        taskCompletionSource: localCompletion,
                         state: Tuple.Create(this, localCompletion),
                         onSuccess: static state =>
                         {