Replace Thread.Sleep with await Task.Delay (#48)

paulomorgado · web-flow · commit 259c0590b4c1 · 2023-01-27T19:53:59.000-08:00
diff --git a/src/SqlSessionStateProviderAsync/SqlInMemoryTableSessionStateRepository.cs b/src/SqlSessionStateProviderAsync/SqlInMemoryTableSessionStateRepository.cs
@@ -7,6 +7,7 @@ namespace Microsoft.AspNet.SessionState
     using System;
     using System.Data.SqlClient;
     using System.Diagnostics;
+    using System.Runtime.CompilerServices;
     using System.Threading;
     using System.Threading.Tasks;
     using System.Web;
@@ -316,7 +317,7 @@ public void CreateSessionStateTable()
                 try
                 {
                     var cmd = _commandHelper.CreateNewSessionTableCmd(CreateSessionTableSql);
-                    var task = SqlSessionStateRepositoryUtil.SqlExecuteNonQueryWithRetryAsync(connection, cmd, CanRetry).ConfigureAwait(false);
+                    var task = SqlSessionStateRepositoryUtil.SqlExecuteNonQueryWithRetryAsync(connection, cmd, CanRetryAsync).ConfigureAwait(false);
                     task.GetAwaiter().GetResult();
                 }
                 catch (Exception ex)
@@ -343,7 +344,7 @@ public void DeleteExpiredSessions()
             using (var connection = new SqlConnection(_connectString))
             {
                 var cmd = _commandHelper.CreateDeleteExpiredSessionsCmd(DeleteExpiredSessionsSql);
-                var task = SqlSessionStateRepositoryUtil.SqlExecuteNonQueryWithRetryAsync(connection, cmd, CanRetry).ConfigureAwait(false);
+                var task = SqlSessionStateRepositoryUtil.SqlExecuteNonQueryWithRetryAsync(connection, cmd, CanRetryAsync).ConfigureAwait(false);
                 task.GetAwaiter().GetResult();
             }
         }
@@ -369,7 +370,7 @@ public async Task<SessionItem> GetSessionStateItemAsync(string id, bool exclusiv
 
             using (var connection = new SqlConnection(_connectString))
             {
-                using (var reader = await SqlSessionStateRepositoryUtil.SqlExecuteReaderWithRetryAsync(connection, cmd, CanRetry))
+                using (var reader = await SqlSessionStateRepositoryUtil.SqlExecuteReaderWithRetryAsync(connection, cmd, CanRetryAsync))
                 {
                     if (await reader.ReadAsync())
                     {
@@ -419,7 +420,7 @@ public async Task CreateOrUpdateSessionStateItemAsync(bool newItem, string id,
 
             using (var connection = new SqlConnection(_connectString))
             {
-                await SqlSessionStateRepositoryUtil.SqlExecuteNonQueryWithRetryAsync(connection, cmd, CanRetry, newItem);
+                await SqlSessionStateRepositoryUtil.SqlExecuteNonQueryWithRetryAsync(connection, cmd, CanRetryAsync, newItem);
             }
         }
 
@@ -428,7 +429,7 @@ public async Task ResetSessionItemTimeoutAsync(string id)
             var cmd = _commandHelper.CreateResetItemTimeoutCmd(ResetItemTimeoutSql, id);
             using (var connection = new SqlConnection(_connectString))
             {
-                await SqlSessionStateRepositoryUtil.SqlExecuteNonQueryWithRetryAsync(connection, cmd, CanRetry);
+                await SqlSessionStateRepositoryUtil.SqlExecuteNonQueryWithRetryAsync(connection, cmd, CanRetryAsync);
             }
         }
 
@@ -437,7 +438,7 @@ public async Task RemoveSessionItemAsync(string id, object lockId)
             var cmd = _commandHelper.CreateRemoveStateItemCmd(RemoveStateItemSql, id, lockId);
             using (var connection = new SqlConnection(_connectString))
             {
-                await SqlSessionStateRepositoryUtil.SqlExecuteNonQueryWithRetryAsync(connection, cmd, CanRetry);
+                await SqlSessionStateRepositoryUtil.SqlExecuteNonQueryWithRetryAsync(connection, cmd, CanRetryAsync);
             }
         }
 
@@ -446,7 +447,7 @@ public async Task ReleaseSessionItemAsync(string id, object lockId)
             var cmd = _commandHelper.CreateReleaseItemExclusiveCmd(ReleaseItemExclusiveSql, id, lockId);
             using (var connection = new SqlConnection(_connectString))
             {
-                await SqlSessionStateRepositoryUtil.SqlExecuteNonQueryWithRetryAsync(connection, cmd, CanRetry);
+                await SqlSessionStateRepositoryUtil.SqlExecuteNonQueryWithRetryAsync(connection, cmd, CanRetryAsync);
             }
         }
 
@@ -455,26 +456,33 @@ public async Task CreateUninitializedSessionItemAsync(string id, int length, byt
             var cmd = _commandHelper.CreateTempInsertUninitializedItemCmd(TempInsertUninitializedItemSql, id, length, buf, timeout);
             using (var connection = new SqlConnection(_connectString))
             {
-                await SqlSessionStateRepositoryUtil.SqlExecuteNonQueryWithRetryAsync(connection, cmd, CanRetry, true);
+                await SqlSessionStateRepositoryUtil.SqlExecuteNonQueryWithRetryAsync(connection, cmd, CanRetryAsync, true);
             }
         }
 
-        private bool CanRetry(RetryCheckParameter parameter)
+        private Task<bool> CanRetryAsync(RetryCheckParameter parameter)
         {
             if (parameter.RetryCount >= _maxRetryNum ||
                 !ShouldUseInMemoryTableRetry(parameter.Exception))
             {
-                return false;
+                return Task.FromResult(false);
             }
 
+            return WaitToRetryAsync(parameter, _retryIntervalMilSec);
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        private static async Task<bool> WaitToRetryAsync(RetryCheckParameter parameter, int retryIntervalMilSec)
+        {
             // this actually may sleep up to 15ms
             // but it's better than spinning CPU
-            Thread.Sleep(_retryIntervalMilSec);
+            await Task.Delay(retryIntervalMilSec);
             parameter.RetryCount++;
 
             return true;
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private bool ShouldUseInMemoryTableRetry(SqlException ex)
         {
             // Error code is defined on
diff --git a/src/SqlSessionStateProviderAsync/SqlSessionStateRepository.cs b/src/SqlSessionStateProviderAsync/SqlSessionStateRepository.cs
@@ -6,7 +6,7 @@ namespace Microsoft.AspNet.SessionState
     using Resources;
     using System;
     using System.Data.SqlClient;
-    using System.Threading;
+    using System.Runtime.CompilerServices;
     using System.Threading.Tasks;
     using System.Web;
     using System.Web.SessionState;
@@ -47,10 +47,10 @@ Created             datetime        NOT NULL DEFAULT GETUTCDATE(),
                 ) 
                 CREATE NONCLUSTERED INDEX Index_Expires ON {SqlSessionStateRepositoryUtil.TableName} (Expires)
             END";
-            #endregion
+        #endregion
 
         #region TempInsertUninitializedItem
-            private static readonly string TempInsertUninitializedItemSql = $@"
+        private static readonly string TempInsertUninitializedItemSql = $@"
             DECLARE @now AS datetime
             DECLARE @nowLocal AS datetime
             SET @now = GETUTCDATE()
@@ -75,10 +75,10 @@ DECLARE @nowLocal AS datetime
                  @nowLocal,
                  1,
                  1)";
-            #endregion
+        #endregion
 
         #region GetStateItemExclusive
-            private static readonly string GetStateItemExclusiveSql = $@"
+        private static readonly string GetStateItemExclusiveSql = $@"
             BEGIN TRAN
                 DECLARE @textptr AS varbinary(16)
                 DECLARE @length AS int
@@ -275,7 +275,7 @@ DEALLOCATE ExpiredSessionCursor
             END 
 
             DROP TABLE #tblExpiredSessions";
-            #endregion
+        #endregion
         #endregion
 
         public SqlSessionStateRepository(string connectionString, int commandTimeout,
@@ -310,17 +310,23 @@ internal int CommandTimeout
         }
         #endregion
 
-        private bool CanRetry(RetryCheckParameter parameter)
+        private Task<bool> CanRetryAsync(RetryCheckParameter parameter)
         {
             if (_retryIntervalMilSec <= 0 ||
                 !SqlSessionStateRepositoryUtil.IsFatalSqlException(parameter.Exception) ||
                 parameter.RetryCount >= _maxRetryNum)
             {
-                return false;
+                return Task.FromResult(false);
             }
 
+            return WaitToRetryAsync(parameter, _retryIntervalMilSec);
+        }
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        private static async Task<bool> WaitToRetryAsync(RetryCheckParameter parameter, int retryIntervalMilSec)
+        {
             // sleep the specified time and allow retry
-            Thread.Sleep(_retryIntervalMilSec);
+            await Task.Delay(retryIntervalMilSec);
             parameter.RetryCount++;
 
             return true;
@@ -334,7 +340,7 @@ public void CreateSessionStateTable()
                 try
                 {
                     var cmd = _commandHelper.CreateNewSessionTableCmd(CreateSessionTableSql);
-                    var task = SqlSessionStateRepositoryUtil.SqlExecuteNonQueryWithRetryAsync(connection, cmd, CanRetry).ConfigureAwait(false);
+                    var task = SqlSessionStateRepositoryUtil.SqlExecuteNonQueryWithRetryAsync(connection, cmd, CanRetryAsync).ConfigureAwait(false);
                     task.GetAwaiter().GetResult();
                 }
                 catch (Exception ex)
@@ -349,7 +355,7 @@ public void DeleteExpiredSessions()
             using (var connection = new SqlConnection(_connectString))
             {
                 var cmd = _commandHelper.CreateDeleteExpiredSessionsCmd(DeleteExpiredSessionsSql);
-                var task = SqlSessionStateRepositoryUtil.SqlExecuteNonQueryWithRetryAsync(connection, cmd, CanRetry).ConfigureAwait(false);
+                var task = SqlSessionStateRepositoryUtil.SqlExecuteNonQueryWithRetryAsync(connection, cmd, CanRetryAsync).ConfigureAwait(false);
                 task.GetAwaiter().GetResult();
             }
         }
@@ -375,7 +381,7 @@ public async Task<SessionItem> GetSessionStateItemAsync(string id, bool exclusiv
 
             using (var connection = new SqlConnection(_connectString))
             {
-                using (var reader = await SqlSessionStateRepositoryUtil.SqlExecuteReaderWithRetryAsync(connection, cmd, CanRetry))
+                using (var reader = await SqlSessionStateRepositoryUtil.SqlExecuteReaderWithRetryAsync(connection, cmd, CanRetryAsync))
                 {
                     if (await reader.ReadAsync())
                     {
@@ -427,7 +433,7 @@ public async Task CreateOrUpdateSessionStateItemAsync(bool newItem, string id, b
 
             using (var connection = new SqlConnection(_connectString))
             {
-                await SqlSessionStateRepositoryUtil.SqlExecuteNonQueryWithRetryAsync(connection, cmd, CanRetry, newItem);
+                await SqlSessionStateRepositoryUtil.SqlExecuteNonQueryWithRetryAsync(connection, cmd, CanRetryAsync, newItem);
             }
         }
 
@@ -436,7 +442,7 @@ public async Task ResetSessionItemTimeoutAsync(string id)
             var cmd = _commandHelper.CreateResetItemTimeoutCmd(ResetItemTimeoutSql, id);
             using (var connection = new SqlConnection(_connectString))
             {
-                await SqlSessionStateRepositoryUtil.SqlExecuteNonQueryWithRetryAsync(connection, cmd, CanRetry);
+                await SqlSessionStateRepositoryUtil.SqlExecuteNonQueryWithRetryAsync(connection, cmd, CanRetryAsync);
             }
         }
 
@@ -445,7 +451,7 @@ public async Task RemoveSessionItemAsync(string id, object lockId)
             var cmd = _commandHelper.CreateRemoveStateItemCmd(RemoveStateItemSql, id, lockId);
             using (var connection = new SqlConnection(_connectString))
             {
-                await SqlSessionStateRepositoryUtil.SqlExecuteNonQueryWithRetryAsync(connection, cmd, CanRetry);
+                await SqlSessionStateRepositoryUtil.SqlExecuteNonQueryWithRetryAsync(connection, cmd, CanRetryAsync);
             }
         }
 
@@ -454,7 +460,7 @@ public async Task ReleaseSessionItemAsync(string id, object lockId)
             var cmd = _commandHelper.CreateReleaseItemExclusiveCmd(ReleaseItemExclusiveSql, id, lockId);
             using (var connection = new SqlConnection(_connectString))
             {
-                await SqlSessionStateRepositoryUtil.SqlExecuteNonQueryWithRetryAsync(connection, cmd, CanRetry);
+                await SqlSessionStateRepositoryUtil.SqlExecuteNonQueryWithRetryAsync(connection, cmd, CanRetryAsync);
             }
         }
 
@@ -463,10 +469,10 @@ public async Task CreateUninitializedSessionItemAsync(string id, int length, byt
             var cmd = _commandHelper.CreateTempInsertUninitializedItemCmd(TempInsertUninitializedItemSql, id, length, buf, timeout);
             using (var connection = new SqlConnection(_connectString))
             {
-                await SqlSessionStateRepositoryUtil.SqlExecuteNonQueryWithRetryAsync(connection, cmd, CanRetry, true);
+                await SqlSessionStateRepositoryUtil.SqlExecuteNonQueryWithRetryAsync(connection, cmd, CanRetryAsync, true);
             }
         }
         #endregion
-        
-    }    
+
+    }
 }
diff --git a/src/SqlSessionStateProviderAsync/SqlSessionStateRepositoryUtil.cs b/src/SqlSessionStateProviderAsync/SqlSessionStateRepositoryUtil.cs
@@ -7,6 +7,7 @@ namespace Microsoft.AspNet.SessionState
     using System;
     using System.Data;
     using System.Data.SqlClient;
+using System.Runtime.CompilerServices;
     using System.Security.Principal;
     using System.Threading.Tasks;
     using System.Web;
@@ -61,7 +62,7 @@ class SqlSessionStateRepositoryUtil
         public static readonly int DefaultItemLength = 7000;
 
         public static async Task<int> SqlExecuteNonQueryWithRetryAsync(SqlConnection connection, SqlCommand sqlCmd, 
-            Func<RetryCheckParameter, bool> canRetry, bool ignoreInsertPKException = false)
+            Func<RetryCheckParameter, Task<bool>> canRetry, bool ignoreInsertPKException = false)
         {
             var retryParamenter = new RetryCheckParameter() { EndRetryTime = DateTime.UtcNow, RetryCount = 0 };
             sqlCmd.Connection = connection;
@@ -84,15 +85,15 @@ public static async Task<int> SqlExecuteNonQueryWithRetryAsync(SqlConnection con
                     }
 
                     retryParamenter.Exception = e;
-                    if (!canRetry(retryParamenter))
+                    if (!(await canRetry(retryParamenter)))
                     {
                         throw;
                     }
                 }
             }
         }
 
-        public static async Task<SqlDataReader> SqlExecuteReaderWithRetryAsync(SqlConnection connection, SqlCommand sqlCmd, Func<RetryCheckParameter, bool> canRetry, 
+        public static async Task<SqlDataReader> SqlExecuteReaderWithRetryAsync(SqlConnection connection, SqlCommand sqlCmd, Func<RetryCheckParameter, Task<bool>> canRetry, 
             CommandBehavior cmdBehavior = CommandBehavior.Default)
         {
             var retryParamenter = new RetryCheckParameter() { EndRetryTime = DateTime.UtcNow, RetryCount = 0 };
@@ -109,14 +110,15 @@ public static async Task<SqlDataReader> SqlExecuteReaderWithRetryAsync(SqlConnec
                 catch (SqlException e)
                 {
                     retryParamenter.Exception = e;
-                    if (!canRetry(retryParamenter))
+                    if (!(await canRetry(retryParamenter)))
                     {
                         throw;
                     }
                 }
             }
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static bool IsFatalSqlException(SqlException ex)
         {
             // We will retry sql operations for serious errors.

Original file line number	Diff line number	Diff line change
`@@ -7,6 +7,7 @@ namespace Microsoft.AspNet.SessionState`
`7`	`7`	`using System;`
`8`	`8`	`using System.Data.SqlClient;`
`9`	`9`	`using System.Diagnostics;`
	`10`	`+ using System.Runtime.CompilerServices;`
`10`	`11`	`using System.Threading;`
`11`	`12`	`using System.Threading.Tasks;`
`12`	`13`	`using System.Web;`
`@@ -316,7 +317,7 @@ public void CreateSessionStateTable()`
`316`	`317`	`try`
`317`	`318`	`{`
`318`	`319`	`var cmd = _commandHelper.CreateNewSessionTableCmd(CreateSessionTableSql);`
`319`		`- var task = SqlSessionStateRepositoryUtil.SqlExecuteNonQueryWithRetryAsync(connection, cmd, CanRetry).ConfigureAwait(false);`
	`320`	`+ var task = SqlSessionStateRepositoryUtil.SqlExecuteNonQueryWithRetryAsync(connection, cmd, CanRetryAsync).ConfigureAwait(false);`
`320`	`321`	`task.GetAwaiter().GetResult();`
`321`	`322`	`}`
`322`	`323`	`catch (Exception ex)`
`@@ -343,7 +344,7 @@ public void DeleteExpiredSessions()`
`343`	`344`	`using (var connection = new SqlConnection(_connectString))`
`344`	`345`	`{`
`345`	`346`	`var cmd = _commandHelper.CreateDeleteExpiredSessionsCmd(DeleteExpiredSessionsSql);`
`346`		`- var task = SqlSessionStateRepositoryUtil.SqlExecuteNonQueryWithRetryAsync(connection, cmd, CanRetry).ConfigureAwait(false);`
	`347`	`+ var task = SqlSessionStateRepositoryUtil.SqlExecuteNonQueryWithRetryAsync(connection, cmd, CanRetryAsync).ConfigureAwait(false);`
`347`	`348`	`task.GetAwaiter().GetResult();`
`348`	`349`	`}`
`349`	`350`	`}`
`@@ -369,7 +370,7 @@ public async Task<SessionItem> GetSessionStateItemAsync(string id, bool exclusiv`
`369`	`370`
`370`	`371`	`using (var connection = new SqlConnection(_connectString))`
`371`	`372`	`{`
`372`		`- using (var reader = await SqlSessionStateRepositoryUtil.SqlExecuteReaderWithRetryAsync(connection, cmd, CanRetry))`
	`373`	`+ using (var reader = await SqlSessionStateRepositoryUtil.SqlExecuteReaderWithRetryAsync(connection, cmd, CanRetryAsync))`
`373`	`374`	`{`
`374`	`375`	`if (await reader.ReadAsync())`
`375`	`376`	`{`
`@@ -419,7 +420,7 @@ public async Task CreateOrUpdateSessionStateItemAsync(bool newItem, string id,`
`419`	`420`
`420`	`421`	`using (var connection = new SqlConnection(_connectString))`
`421`	`422`	`{`
`422`		`- await SqlSessionStateRepositoryUtil.SqlExecuteNonQueryWithRetryAsync(connection, cmd, CanRetry, newItem);`
	`423`	`+ await SqlSessionStateRepositoryUtil.SqlExecuteNonQueryWithRetryAsync(connection, cmd, CanRetryAsync, newItem);`
`423`	`424`	`}`
`424`	`425`	`}`
`425`	`426`
`@@ -428,7 +429,7 @@ public async Task ResetSessionItemTimeoutAsync(string id)`
`428`	`429`	`var cmd = _commandHelper.CreateResetItemTimeoutCmd(ResetItemTimeoutSql, id);`
`429`	`430`	`using (var connection = new SqlConnection(_connectString))`
`430`	`431`	`{`
`431`		`- await SqlSessionStateRepositoryUtil.SqlExecuteNonQueryWithRetryAsync(connection, cmd, CanRetry);`
	`432`	`+ await SqlSessionStateRepositoryUtil.SqlExecuteNonQueryWithRetryAsync(connection, cmd, CanRetryAsync);`
`432`	`433`	`}`
`433`	`434`	`}`
`434`	`435`
`@@ -437,7 +438,7 @@ public async Task RemoveSessionItemAsync(string id, object lockId)`
`437`	`438`	`var cmd = _commandHelper.CreateRemoveStateItemCmd(RemoveStateItemSql, id, lockId);`
`438`	`439`	`using (var connection = new SqlConnection(_connectString))`
`439`	`440`	`{`
`440`		`- await SqlSessionStateRepositoryUtil.SqlExecuteNonQueryWithRetryAsync(connection, cmd, CanRetry);`
	`441`	`+ await SqlSessionStateRepositoryUtil.SqlExecuteNonQueryWithRetryAsync(connection, cmd, CanRetryAsync);`
`441`	`442`	`}`
`442`	`443`	`}`
`443`	`444`
`@@ -446,7 +447,7 @@ public async Task ReleaseSessionItemAsync(string id, object lockId)`
`446`	`447`	`var cmd = _commandHelper.CreateReleaseItemExclusiveCmd(ReleaseItemExclusiveSql, id, lockId);`
`447`	`448`	`using (var connection = new SqlConnection(_connectString))`
`448`	`449`	`{`
`449`		`- await SqlSessionStateRepositoryUtil.SqlExecuteNonQueryWithRetryAsync(connection, cmd, CanRetry);`
	`450`	`+ await SqlSessionStateRepositoryUtil.SqlExecuteNonQueryWithRetryAsync(connection, cmd, CanRetryAsync);`
`450`	`451`	`}`
`451`	`452`	`}`
`452`	`453`
`@@ -455,26 +456,33 @@ public async Task CreateUninitializedSessionItemAsync(string id, int length, byt`
`455`	`456`	`var cmd = _commandHelper.CreateTempInsertUninitializedItemCmd(TempInsertUninitializedItemSql, id, length, buf, timeout);`
`456`	`457`	`using (var connection = new SqlConnection(_connectString))`
`457`	`458`	`{`
`458`		`- await SqlSessionStateRepositoryUtil.SqlExecuteNonQueryWithRetryAsync(connection, cmd, CanRetry, true);`
	`459`	`+ await SqlSessionStateRepositoryUtil.SqlExecuteNonQueryWithRetryAsync(connection, cmd, CanRetryAsync, true);`
`459`	`460`	`}`
`460`	`461`	`}`
`461`	`462`
`462`		`- private bool CanRetry(RetryCheckParameter parameter)`
	`463`	`+ private Task<bool> CanRetryAsync(RetryCheckParameter parameter)`
`463`	`464`	`{`
`464`	`465`	`if (parameter.RetryCount >= _maxRetryNum \|\|`
`465`	`466`	`!ShouldUseInMemoryTableRetry(parameter.Exception))`
`466`	`467`	`{`
`467`		`- return false;`
	`468`	`+ return Task.FromResult(false);`
`468`	`469`	`}`
`469`	`470`
	`471`	`+ return WaitToRetryAsync(parameter, _retryIntervalMilSec);`
	`472`	`+ }`
	`473`	`+`
	`474`	`+ [MethodImpl(MethodImplOptions.NoInlining)]`
	`475`	`+ private static async Task<bool> WaitToRetryAsync(RetryCheckParameter parameter, int retryIntervalMilSec)`
	`476`	`+ {`
`470`	`477`	`// this actually may sleep up to 15ms`
`471`	`478`	`// but it's better than spinning CPU`
`472`		`- Thread.Sleep(_retryIntervalMilSec);`
	`479`	`+ await Task.Delay(retryIntervalMilSec);`
`473`	`480`	`parameter.RetryCount++;`
`474`	`481`
`475`	`482`	`return true;`
`476`	`483`	`}`
`477`	`484`
	`485`	`+ [MethodImpl(MethodImplOptions.AggressiveInlining)]`
`478`	`486`	`private bool ShouldUseInMemoryTableRetry(SqlException ex)`
`479`	`487`	`{`
`480`	`488`	`// Error code is defined on`
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,7 @@ namespace Microsoft.AspNet.SessionState`
`6`	`6`	`using Resources;`
`7`	`7`	`using System;`
`8`	`8`	`using System.Data.SqlClient;`
`9`		`- using System.Threading;`
	`9`	`+ using System.Runtime.CompilerServices;`
`10`	`10`	`using System.Threading.Tasks;`
`11`	`11`	`using System.Web;`
`12`	`12`	`using System.Web.SessionState;`
`@@ -47,10 +47,10 @@ Created datetime NOT NULL DEFAULT GETUTCDATE(),`
`47`	`47`	`)`
`48`	`48`	`CREATE NONCLUSTERED INDEX Index_Expires ON {SqlSessionStateRepositoryUtil.TableName} (Expires)`
`49`	`49`	`END";`
`50`		`- #endregion`
	`50`	`+ #endregion`
`51`	`51`
`52`	`52`	`#region TempInsertUninitializedItem`
`53`		`- private static readonly string TempInsertUninitializedItemSql = $@"`
	`53`	`+ private static readonly string TempInsertUninitializedItemSql = $@"`
`54`	`54`	`DECLARE @now AS datetime`
`55`	`55`	`DECLARE @nowLocal AS datetime`
`56`	`56`	`SET @now = GETUTCDATE()`
`@@ -75,10 +75,10 @@ DECLARE @nowLocal AS datetime`
`75`	`75`	`@nowLocal,`
`76`	`76`	`1,`
`77`	`77`	`1)";`
`78`		`- #endregion`
	`78`	`+ #endregion`
`79`	`79`
`80`	`80`	`#region GetStateItemExclusive`
`81`		`- private static readonly string GetStateItemExclusiveSql = $@"`
	`81`	`+ private static readonly string GetStateItemExclusiveSql = $@"`
`82`	`82`	`BEGIN TRAN`
`83`	`83`	`DECLARE @textptr AS varbinary(16)`
`84`	`84`	`DECLARE @length AS int`
`@@ -275,7 +275,7 @@ DEALLOCATE ExpiredSessionCursor`
`275`	`275`	`END`
`276`	`276`
`277`	`277`	`DROP TABLE #tblExpiredSessions";`
`278`		`- #endregion`
	`278`	`+ #endregion`
`279`	`279`	`#endregion`
`280`	`280`
`281`	`281`	`public SqlSessionStateRepository(string connectionString, int commandTimeout,`
`@@ -310,17 +310,23 @@ internal int CommandTimeout`
`310`	`310`	`}`
`311`	`311`	`#endregion`
`312`	`312`
`313`		`- private bool CanRetry(RetryCheckParameter parameter)`
	`313`	`+ private Task<bool> CanRetryAsync(RetryCheckParameter parameter)`
`314`	`314`	`{`
`315`	`315`	`if (_retryIntervalMilSec <= 0 \|\|`
`316`	`316`	`!SqlSessionStateRepositoryUtil.IsFatalSqlException(parameter.Exception) \|\|`
`317`	`317`	`parameter.RetryCount >= _maxRetryNum)`
`318`	`318`	`{`
`319`		`- return false;`
	`319`	`+ return Task.FromResult(false);`
`320`	`320`	`}`
`321`	`321`
	`322`	`+ return WaitToRetryAsync(parameter, _retryIntervalMilSec);`
	`323`	`+ }`
	`324`	`+`
	`325`	`+ [MethodImpl(MethodImplOptions.NoInlining)]`
	`326`	`+ private static async Task<bool> WaitToRetryAsync(RetryCheckParameter parameter, int retryIntervalMilSec)`
	`327`	`+ {`
`322`	`328`	`// sleep the specified time and allow retry`
`323`		`- Thread.Sleep(_retryIntervalMilSec);`
	`329`	`+ await Task.Delay(retryIntervalMilSec);`
`324`	`330`	`parameter.RetryCount++;`
`325`	`331`
`326`	`332`	`return true;`
`@@ -334,7 +340,7 @@ public void CreateSessionStateTable()`
`334`	`340`	`try`
`335`	`341`	`{`
`336`	`342`	`var cmd = _commandHelper.CreateNewSessionTableCmd(CreateSessionTableSql);`
`337`		`- var task = SqlSessionStateRepositoryUtil.SqlExecuteNonQueryWithRetryAsync(connection, cmd, CanRetry).ConfigureAwait(false);`
	`343`	`+ var task = SqlSessionStateRepositoryUtil.SqlExecuteNonQueryWithRetryAsync(connection, cmd, CanRetryAsync).ConfigureAwait(false);`
`338`	`344`	`task.GetAwaiter().GetResult();`
`339`	`345`	`}`
`340`	`346`	`catch (Exception ex)`
`@@ -349,7 +355,7 @@ public void DeleteExpiredSessions()`
`349`	`355`	`using (var connection = new SqlConnection(_connectString))`
`350`	`356`	`{`
`351`	`357`	`var cmd = _commandHelper.CreateDeleteExpiredSessionsCmd(DeleteExpiredSessionsSql);`
`352`		`- var task = SqlSessionStateRepositoryUtil.SqlExecuteNonQueryWithRetryAsync(connection, cmd, CanRetry).ConfigureAwait(false);`
	`358`	`+ var task = SqlSessionStateRepositoryUtil.SqlExecuteNonQueryWithRetryAsync(connection, cmd, CanRetryAsync).ConfigureAwait(false);`
`353`	`359`	`task.GetAwaiter().GetResult();`
`354`	`360`	`}`
`355`	`361`	`}`
`@@ -375,7 +381,7 @@ public async Task<SessionItem> GetSessionStateItemAsync(string id, bool exclusiv`
`375`	`381`
`376`	`382`	`using (var connection = new SqlConnection(_connectString))`
`377`	`383`	`{`
`378`		`- using (var reader = await SqlSessionStateRepositoryUtil.SqlExecuteReaderWithRetryAsync(connection, cmd, CanRetry))`
	`384`	`+ using (var reader = await SqlSessionStateRepositoryUtil.SqlExecuteReaderWithRetryAsync(connection, cmd, CanRetryAsync))`
`379`	`385`	`{`
`380`	`386`	`if (await reader.ReadAsync())`
`381`	`387`	`{`
`@@ -427,7 +433,7 @@ public async Task CreateOrUpdateSessionStateItemAsync(bool newItem, string id, b`
`427`	`433`
`428`	`434`	`using (var connection = new SqlConnection(_connectString))`
`429`	`435`	`{`
`430`		`- await SqlSessionStateRepositoryUtil.SqlExecuteNonQueryWithRetryAsync(connection, cmd, CanRetry, newItem);`
	`436`	`+ await SqlSessionStateRepositoryUtil.SqlExecuteNonQueryWithRetryAsync(connection, cmd, CanRetryAsync, newItem);`
`431`	`437`	`}`
`432`	`438`	`}`
`433`	`439`
`@@ -436,7 +442,7 @@ public async Task ResetSessionItemTimeoutAsync(string id)`
`436`	`442`	`var cmd = _commandHelper.CreateResetItemTimeoutCmd(ResetItemTimeoutSql, id);`
`437`	`443`	`using (var connection = new SqlConnection(_connectString))`
`438`	`444`	`{`
`439`		`- await SqlSessionStateRepositoryUtil.SqlExecuteNonQueryWithRetryAsync(connection, cmd, CanRetry);`
	`445`	`+ await SqlSessionStateRepositoryUtil.SqlExecuteNonQueryWithRetryAsync(connection, cmd, CanRetryAsync);`
`440`	`446`	`}`
`441`	`447`	`}`
`442`	`448`
`@@ -445,7 +451,7 @@ public async Task RemoveSessionItemAsync(string id, object lockId)`
`445`	`451`	`var cmd = _commandHelper.CreateRemoveStateItemCmd(RemoveStateItemSql, id, lockId);`
`446`	`452`	`using (var connection = new SqlConnection(_connectString))`
`447`	`453`	`{`
`448`		`- await SqlSessionStateRepositoryUtil.SqlExecuteNonQueryWithRetryAsync(connection, cmd, CanRetry);`
	`454`	`+ await SqlSessionStateRepositoryUtil.SqlExecuteNonQueryWithRetryAsync(connection, cmd, CanRetryAsync);`
`449`	`455`	`}`
`450`	`456`	`}`
`451`	`457`
`@@ -454,7 +460,7 @@ public async Task ReleaseSessionItemAsync(string id, object lockId)`
`454`	`460`	`var cmd = _commandHelper.CreateReleaseItemExclusiveCmd(ReleaseItemExclusiveSql, id, lockId);`
`455`	`461`	`using (var connection = new SqlConnection(_connectString))`
`456`	`462`	`{`
`457`		`- await SqlSessionStateRepositoryUtil.SqlExecuteNonQueryWithRetryAsync(connection, cmd, CanRetry);`
	`463`	`+ await SqlSessionStateRepositoryUtil.SqlExecuteNonQueryWithRetryAsync(connection, cmd, CanRetryAsync);`
`458`	`464`	`}`
`459`	`465`	`}`
`460`	`466`
`@@ -463,10 +469,10 @@ public async Task CreateUninitializedSessionItemAsync(string id, int length, byt`
`463`	`469`	`var cmd = _commandHelper.CreateTempInsertUninitializedItemCmd(TempInsertUninitializedItemSql, id, length, buf, timeout);`
`464`	`470`	`using (var connection = new SqlConnection(_connectString))`
`465`	`471`	`{`
`466`		`- await SqlSessionStateRepositoryUtil.SqlExecuteNonQueryWithRetryAsync(connection, cmd, CanRetry, true);`
	`472`	`+ await SqlSessionStateRepositoryUtil.SqlExecuteNonQueryWithRetryAsync(connection, cmd, CanRetryAsync, true);`
`467`	`473`	`}`
`468`	`474`	`}`
`469`	`475`	`#endregion`
`470`		`-`
`471`		`- }`
	`476`	`+`
	`477`	`+ }`
`472`	`478`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,6 +7,7 @@ namespace Microsoft.AspNet.SessionState`
`7`	`7`	`using System;`
`8`	`8`	`using System.Data;`
`9`	`9`	`using System.Data.SqlClient;`
	`10`	`+using System.Runtime.CompilerServices;`
`10`	`11`	`using System.Security.Principal;`
`11`	`12`	`using System.Threading.Tasks;`
`12`	`13`	`using System.Web;`
`@@ -61,7 +62,7 @@ class SqlSessionStateRepositoryUtil`
`61`	`62`	`public static readonly int DefaultItemLength = 7000;`
`62`	`63`
`63`	`64`	`public static async Task<int> SqlExecuteNonQueryWithRetryAsync(SqlConnection connection, SqlCommand sqlCmd,`
`64`		`- Func<RetryCheckParameter, bool> canRetry, bool ignoreInsertPKException = false)`
	`65`	`+ Func<RetryCheckParameter, Task<bool>> canRetry, bool ignoreInsertPKException = false)`
`65`	`66`	`{`
`66`	`67`	`var retryParamenter = new RetryCheckParameter() { EndRetryTime = DateTime.UtcNow, RetryCount = 0 };`
`67`	`68`	`sqlCmd.Connection = connection;`
`@@ -84,15 +85,15 @@ public static async Task<int> SqlExecuteNonQueryWithRetryAsync(SqlConnection con`
`84`	`85`	`}`
`85`	`86`
`86`	`87`	`retryParamenter.Exception = e;`
`87`		`- if (!canRetry(retryParamenter))`
	`88`	`+ if (!(await canRetry(retryParamenter)))`
`88`	`89`	`{`
`89`	`90`	`throw;`
`90`	`91`	`}`
`91`	`92`	`}`
`92`	`93`	`}`
`93`	`94`	`}`
`94`	`95`
`95`		`- public static async Task<SqlDataReader> SqlExecuteReaderWithRetryAsync(SqlConnection connection, SqlCommand sqlCmd, Func<RetryCheckParameter, bool> canRetry,`
	`96`	`+ public static async Task<SqlDataReader> SqlExecuteReaderWithRetryAsync(SqlConnection connection, SqlCommand sqlCmd, Func<RetryCheckParameter, Task<bool>> canRetry,`
`96`	`97`	`CommandBehavior cmdBehavior = CommandBehavior.Default)`
`97`	`98`	`{`
`98`	`99`	`var retryParamenter = new RetryCheckParameter() { EndRetryTime = DateTime.UtcNow, RetryCount = 0 };`
`@@ -109,14 +110,15 @@ public static async Task<SqlDataReader> SqlExecuteReaderWithRetryAsync(SqlConnec`
`109`	`110`	`catch (SqlException e)`
`110`	`111`	`{`
`111`	`112`	`retryParamenter.Exception = e;`
`112`		`- if (!canRetry(retryParamenter))`
	`113`	`+ if (!(await canRetry(retryParamenter)))`
`113`	`114`	`{`
`114`	`115`	`throw;`
`115`	`116`	`}`
`116`	`117`	`}`
`117`	`118`	`}`
`118`	`119`	`}`
`119`	`120`
	`121`	`+ [MethodImpl(MethodImplOptions.AggressiveInlining)]`
`120`	`122`	`public static bool IsFatalSqlException(SqlException ex)`
`121`	`123`	`{`
`122`	`124`	`// We will retry sql operations for serious errors.`