Perf: Static delegates (#1060)

* netcore static lambda rework

* minor netcore api cleanup

* netfx static lambda rework

* netcore add strongbox to avoid boxing

* fixup 2 anonymous typed lambdas to be explicit

Author: Wraith2

src/Microsoft.Data.SqlClient/netcore/src/Microsoft/Data/SqlClient/SNI/SNILoadHandle.cs

@@ -14,7 +14,7 @@ internal class SNILoadHandle
         public static readonly SNILoadHandle SingletonInstance = new SNILoadHandle();
 
         public readonly EncryptionOptions _encryptionOption = EncryptionOptions.OFF;
-        public ThreadLocal<SNIError> _lastError = new ThreadLocal<SNIError>(() => { return new SNIError(SNIProviders.INVALID_PROV, 0, TdsEnums.SNI_SUCCESS, string.Empty); });
+        public ThreadLocal<SNIError> _lastError = new ThreadLocal<SNIError>(static () => new SNIError(SNIProviders.INVALID_PROV, 0, TdsEnums.SNI_SUCCESS, string.Empty));
 
         private readonly uint _status = TdsEnums.SNI_SUCCESS;
 

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

@@ -2152,7 +2152,7 @@ internal Task<T> RegisterForConnectionCloseNotification<T>(Task<T> outerTask, ob
         {
             // Connection exists,  schedule removal, will be added to ref collection after calling ValidateAndReconnect
             return outerTask.ContinueWith(
-                continuationFunction: (task, state) =>
+                continuationFunction: static (task, state) =>
                 {
                     Tuple<SqlConnection, object> parameters = (Tuple<SqlConnection, object>)state;
                     SqlConnection connection = parameters.Item1;

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

@@ -34,15 +34,15 @@ internal static Task CreateContinuationTask(Task task, Action onSuccess, Action<
                 TaskCompletionSource<object> completion = new TaskCompletionSource<object>();
                 ContinueTaskWithState(task, completion,
                     state: Tuple.Create(onSuccess, onFailure, completion),
-                    onSuccess: (state) =>
+                    onSuccess: static (object state) =>
                     {
                         var parameters = (Tuple<Action, Action<Exception>, TaskCompletionSource<object>>)state;
                         Action success = parameters.Item1;
                         TaskCompletionSource<object> taskCompletionSource = parameters.Item3;
                         success();
                         taskCompletionSource.SetResult(null);
                     },
-                    onFailure: (exception, state) =>
+                    onFailure: static (Exception exception, object state) =>
                     {
                         var parameters = (Tuple<Action, Action<Exception>, TaskCompletionSource<object>>)state;
                         Action<Exception> failure = parameters.Item2;
@@ -64,7 +64,7 @@ internal static Task CreateContinuationTaskWithState(Task task, object state, Ac
             {
                 var completion = new TaskCompletionSource<object>();
                 ContinueTaskWithState(task, completion, state,
-                    onSuccess: (continueState) =>
+                    onSuccess: (object continueState) =>
                     {
                         onSuccess(continueState);
                         completion.SetResult(null);
@@ -81,12 +81,12 @@ internal static Task CreateContinuationTask<T1, T2>(Task task, Action<T1, T2> on
         }
 
         internal static void ContinueTask(Task task,
-                TaskCompletionSource<object> completion,
-                Action onSuccess,
-                Action<Exception> onFailure = null,
-                Action onCancellation = null,
-                Func<Exception, Exception> exceptionConverter = null
-            )
+            TaskCompletionSource<object> completion,
+            Action onSuccess,
+            Action<Exception> onFailure = null,
+            Action onCancellation = null,
+            Func<Exception, Exception> exceptionConverter = null
+        )
         {
             task.ContinueWith(
                 tsk =>
@@ -145,7 +145,7 @@ internal static void ContinueTaskWithState(Task task,
         )
         {
             task.ContinueWith(
-                tsk =>
+                (Task tsk, object state2) =>
                 {
                     if (tsk.Exception != null)
                     {
@@ -156,7 +156,7 @@ internal static void ContinueTaskWithState(Task task,
                         }
                         try
                         {
-                            onFailure?.Invoke(exc, state);
+                            onFailure?.Invoke(exc, state2);
                         }
                         finally
                         {
@@ -167,7 +167,7 @@ internal static void ContinueTaskWithState(Task task,
                     {
                         try
                         {
-                            onCancellation?.Invoke(state);
+                            onCancellation?.Invoke(state2);
                         }
                         finally
                         {
@@ -178,14 +178,16 @@ internal static void ContinueTaskWithState(Task task,
                     {
                         try
                         {
-                            onSuccess(state);
+                            onSuccess(state2);
                         }
                         catch (Exception e)
                         {
                             completion.SetException(e);
                         }
                     }
-                }, TaskScheduler.Default
+                }, 
+                state: state,
+                scheduler: TaskScheduler.Default
             );
         }
 
@@ -205,25 +207,42 @@ internal static void WaitForCompletion(Task task, int timeout, Action onTimeout
             }
             if (!task.IsCompleted)
             {
-                task.ContinueWith(t => { var ignored = t.Exception; }); //Ensure the task does not leave an unobserved exception
-                if (onTimeout != null)
-                {
-                    onTimeout();
-                }
+                task.ContinueWith(static t => { var ignored = t.Exception; }); //Ensure the task does not leave an unobserved exception
+                onTimeout?.Invoke();
             }
         }
 
-        internal static void SetTimeoutException(TaskCompletionSource<object> completion, int timeout, Func<Exception> exc, CancellationToken ctoken)
+        internal static void SetTimeoutException(TaskCompletionSource<object> completion, int timeout, Func<Exception> onFailure, CancellationToken ctoken)
         {
             if (timeout > 0)
             {
-                Task.Delay(timeout * 1000, ctoken).ContinueWith((tsk) =>
-                {
-                    if (!tsk.IsCanceled && !completion.Task.IsCompleted)
+                Task.Delay(timeout * 1000, ctoken).ContinueWith(
+                    (Task task) =>
                     {
-                        completion.TrySetException(exc());
+                        if (!task.IsCanceled && !completion.Task.IsCompleted)
+                        {
+                            completion.TrySetException(onFailure());
+                        }
                     }
-                });
+                );
+            }
+        }
+
+        internal static void SetTimeoutExceptionWithState(TaskCompletionSource<object> completion, int timeout, object state, Func<object,Exception> onFailure, CancellationToken cancellationToken)
+        {
+            if (timeout > 0)
+            {
+                Task.Delay(timeout * 1000, cancellationToken).ContinueWith(
+                    (Task task, object state) =>
+                    {
+                        if (!task.IsCanceled && !completion.Task.IsCompleted)
+                        {
+                            completion.TrySetException(onFailure(state));
+                        }
+                    },
+                    state: state,
+                    cancellationToken: CancellationToken.None
+                );
             }
         }
     }

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

@@ -8842,7 +8842,7 @@ internal Task TdsExecuteSQLBatch(string text, int timeout, SqlNotificationReques
                     bool taskReleaseConnectionLock = releaseConnectionLock;
                     releaseConnectionLock = false;
                     return executeTask.ContinueWith(
-                        (task, state) =>
+                        static (Task task, object state) =>
                         {
                             Debug.Assert(!task.IsCanceled, "Task should not be canceled");
                             var parameters = (Tuple<TdsParser, TdsParserStateObject, SqlInternalConnectionTds>)state;
@@ -9068,7 +9068,7 @@ internal Task TdsExecuteRPC(SqlCommand cmd, _SqlRPC[] rpcArray, int timeout, boo
                                     if (releaseConnectionLock)
                                     {
                                         task.ContinueWith(
-                                             (_, state) => ((SqlInternalConnectionTds)state)._parserLock.Release(),
+                                             static (Task _, object state) => ((SqlInternalConnectionTds)state)._parserLock.Release(),
                                              state: _connHandler,
                                              TaskScheduler.Default
                                          );

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

@@ -1016,7 +1016,16 @@ internal Task ExecuteFlush()
                     }
                     else
                     {
-                        return AsyncHelper.CreateContinuationTask(writePacketTask, () => { HasPendingData = true; _messageStatus = 0; });
+                        return AsyncHelper.CreateContinuationTaskWithState(
+                            task: writePacketTask, 
+                            state: this,
+                            onSuccess: static (object state) => 
+                            {
+                                TdsParserStateObject stateObject = (TdsParserStateObject)state;
+                                stateObject.HasPendingData = true;
+                                stateObject._messageStatus = 0; 
+                            }
+                        );
                     }
                 }
             }