Merge pull request #2447 from stephentoub/taskcleanup_commondb

saurabh500 · saurabh500 · commit 114441540f9f · 2015-08-17T15:12:48.000-07:00
Cleanup CancellationToken and Task usage in System.Data.Common
diff --git a/src/System.Data.Common/src/System/Data/Common/AdapterUtil.cs b/src/System.Data.Common/src/System/Data/Common/AdapterUtil.cs
@@ -16,21 +16,6 @@ internal static class ADP
         // location so that the catcher of the exception will have the appropriate call stack.
         // This class is used so that there will be compile time checking of error messages.
 
-        static internal Task<T> CreatedTaskWithException<T>(Exception ex)
-        {
-            TaskCompletionSource<T> completion = new TaskCompletionSource<T>();
-            completion.SetException(ex);
-            return completion.Task;
-        }
-
-        static internal Task<T> CreatedTaskWithCancellation<T>()
-        {
-            TaskCompletionSource<T> completion = new TaskCompletionSource<T>();
-            completion.SetCanceled();
-            return completion.Task;
-        }
-
-
         // NOTE: Initializing a Task in SQL CLR requires the "UNSAFE" permission set (http://msdn.microsoft.com/en-us/library/ms172338.aspx)
         // Therefore we are lazily initializing these Tasks to avoid forcing customers to use the "UNSAFE" set when they are actually using no Async features
         static private Task<bool> s_trueTask = null;
diff --git a/src/System.Data.Common/src/System/Data/Common/DbCommand.cs b/src/System.Data.Common/src/System/Data/Common/DbCommand.cs
@@ -150,24 +150,27 @@ public virtual Task<int> ExecuteNonQueryAsync(CancellationToken cancellationToke
         {
             if (cancellationToken.IsCancellationRequested)
             {
-                return ADP.CreatedTaskWithCancellation<int>();
+                return Task.FromCanceled<int>(cancellationToken);
             }
             else
             {
                 CancellationTokenRegistration registration = new CancellationTokenRegistration();
                 if (cancellationToken.CanBeCanceled)
                 {
-                    registration = cancellationToken.Register(CancelIgnoreFailure);
+                    registration = cancellationToken.Register(s => ((DbCommand)s).CancelIgnoreFailure(), this);
                 }
 
                 try
                 {
                     return Task.FromResult<int>(ExecuteNonQuery());
                 }
                 catch (Exception e)
+                {
+                    return Task.FromException<int>(e);
+                }
+                finally
                 {
                     registration.Dispose();
-                    return ADP.CreatedTaskWithException<int>(e);
                 }
             }
         }
@@ -196,24 +199,27 @@ protected virtual Task<DbDataReader> ExecuteDbDataReaderAsync(CommandBehavior be
         {
             if (cancellationToken.IsCancellationRequested)
             {
-                return ADP.CreatedTaskWithCancellation<DbDataReader>();
+                return Task.FromCanceled<DbDataReader>(cancellationToken);
             }
             else
             {
                 CancellationTokenRegistration registration = new CancellationTokenRegistration();
                 if (cancellationToken.CanBeCanceled)
                 {
-                    registration = cancellationToken.Register(CancelIgnoreFailure);
+                    registration = cancellationToken.Register(s => ((DbCommand)s).CancelIgnoreFailure(), this);
                 }
 
                 try
                 {
                     return Task.FromResult<DbDataReader>(ExecuteReader(behavior));
                 }
                 catch (Exception e)
+                {
+                    return Task.FromException<DbDataReader>(e);
+                }
+                finally
                 {
                     registration.Dispose();
-                    return ADP.CreatedTaskWithException<DbDataReader>(e);
                 }
             }
         }
@@ -227,24 +233,27 @@ public virtual Task<object> ExecuteScalarAsync(CancellationToken cancellationTok
         {
             if (cancellationToken.IsCancellationRequested)
             {
-                return ADP.CreatedTaskWithCancellation<object>();
+                return Task.FromCanceled<object>(cancellationToken);
             }
             else
             {
                 CancellationTokenRegistration registration = new CancellationTokenRegistration();
                 if (cancellationToken.CanBeCanceled)
                 {
-                    registration = cancellationToken.Register(CancelIgnoreFailure);
+                    registration = cancellationToken.Register(s => ((DbCommand)s).CancelIgnoreFailure(), this);
                 }
 
                 try
                 {
                     return Task.FromResult<object>(ExecuteScalar());
                 }
                 catch (Exception e)
+                {
+                    return Task.FromException<object>(e);
+                }
+                finally
                 {
                     registration.Dispose();
-                    return ADP.CreatedTaskWithException<object>(e);
                 }
             }
         }
diff --git a/src/System.Data.Common/src/System/Data/Common/DbConnection.cs b/src/System.Data.Common/src/System/Data/Common/DbConnection.cs
@@ -115,26 +115,22 @@ public Task OpenAsync()
 
         public virtual Task OpenAsync(CancellationToken cancellationToken)
         {
-            TaskCompletionSource<object> taskCompletionSource = new TaskCompletionSource<object>();
-
             if (cancellationToken.IsCancellationRequested)
             {
-                taskCompletionSource.SetCanceled();
+                return Task.FromCanceled(cancellationToken);
             }
             else
             {
                 try
                 {
                     Open();
-                    taskCompletionSource.SetResult(null);
+                    return Task.CompletedTask;
                 }
                 catch (Exception e)
                 {
-                    taskCompletionSource.SetException(e);
+                    return Task.FromException(e);
                 }
             }
-
-            return taskCompletionSource.Task;
         }
 
         public void Dispose()
diff --git a/src/System.Data.Common/src/System/Data/Common/DbDataReader.cs b/src/System.Data.Common/src/System/Data/Common/DbDataReader.cs
@@ -188,7 +188,7 @@ virtual public Task<T> GetFieldValueAsync<T>(int ordinal, CancellationToken canc
         {
             if (cancellationToken.IsCancellationRequested)
             {
-                return ADP.CreatedTaskWithCancellation<T>();
+                return Task.FromCanceled<T>(cancellationToken);
             }
             else
             {
@@ -198,7 +198,7 @@ virtual public Task<T> GetFieldValueAsync<T>(int ordinal, CancellationToken canc
                 }
                 catch (Exception e)
                 {
-                    return ADP.CreatedTaskWithException<T>(e);
+                    return Task.FromException<T>(e);
                 }
             }
         }
@@ -216,7 +216,7 @@ virtual public Task<bool> IsDBNullAsync(int ordinal, CancellationToken cancellat
         {
             if (cancellationToken.IsCancellationRequested)
             {
-                return ADP.CreatedTaskWithCancellation<bool>();
+                return Task.FromCanceled<bool>(cancellationToken);
             }
             else
             {
@@ -226,7 +226,7 @@ virtual public Task<bool> IsDBNullAsync(int ordinal, CancellationToken cancellat
                 }
                 catch (Exception e)
                 {
-                    return ADP.CreatedTaskWithException<bool>(e);
+                    return Task.FromException<bool>(e);
                 }
             }
         }
@@ -244,7 +244,7 @@ virtual public Task<bool> ReadAsync(CancellationToken cancellationToken)
         {
             if (cancellationToken.IsCancellationRequested)
             {
-                return ADP.CreatedTaskWithCancellation<bool>();
+                return Task.FromCanceled<bool>(cancellationToken);
             }
             else
             {
@@ -254,7 +254,7 @@ virtual public Task<bool> ReadAsync(CancellationToken cancellationToken)
                 }
                 catch (Exception e)
                 {
-                    return ADP.CreatedTaskWithException<bool>(e);
+                    return Task.FromException<bool>(e);
                 }
             }
         }
@@ -268,7 +268,7 @@ virtual public Task<bool> NextResultAsync(CancellationToken cancellationToken)
         {
             if (cancellationToken.IsCancellationRequested)
             {
-                return ADP.CreatedTaskWithCancellation<bool>();
+                return Task.FromCanceled<bool>(cancellationToken);
             }
             else
             {
@@ -278,7 +278,7 @@ virtual public Task<bool> NextResultAsync(CancellationToken cancellationToken)
                 }
                 catch (Exception e)
                 {
-                    return ADP.CreatedTaskWithException<bool>(e);
+                    return Task.FromException<bool>(e);
                 }
             }
         }

Original file line number	Diff line number	Diff line change
`@@ -150,24 +150,27 @@ public virtual Task<int> ExecuteNonQueryAsync(CancellationToken cancellationToke`
`150`	`150`	`{`
`151`	`151`	`if (cancellationToken.IsCancellationRequested)`
`152`	`152`	`{`
`153`		`- return ADP.CreatedTaskWithCancellation<int>();`
	`153`	`+ return Task.FromCanceled<int>(cancellationToken);`
`154`	`154`	`}`
`155`	`155`	`else`
`156`	`156`	`{`
`157`	`157`	`CancellationTokenRegistration registration = new CancellationTokenRegistration();`
`158`	`158`	`if (cancellationToken.CanBeCanceled)`
`159`	`159`	`{`
`160`		`- registration = cancellationToken.Register(CancelIgnoreFailure);`
	`160`	`+ registration = cancellationToken.Register(s => ((DbCommand)s).CancelIgnoreFailure(), this);`
`161`	`161`	`}`
`162`	`162`
`163`	`163`	`try`
`164`	`164`	`{`
`165`	`165`	`return Task.FromResult<int>(ExecuteNonQuery());`
`166`	`166`	`}`
`167`	`167`	`catch (Exception e)`
	`168`	`+ {`
	`169`	`+ return Task.FromException<int>(e);`
	`170`	`+ }`
	`171`	`+ finally`
`168`	`172`	`{`
`169`	`173`	`registration.Dispose();`
`170`		`- return ADP.CreatedTaskWithException<int>(e);`
`171`	`174`	`}`
`172`	`175`	`}`
`173`	`176`	`}`
`@@ -196,24 +199,27 @@ protected virtual Task<DbDataReader> ExecuteDbDataReaderAsync(CommandBehavior be`
`196`	`199`	`{`
`197`	`200`	`if (cancellationToken.IsCancellationRequested)`
`198`	`201`	`{`
`199`		`- return ADP.CreatedTaskWithCancellation<DbDataReader>();`
	`202`	`+ return Task.FromCanceled<DbDataReader>(cancellationToken);`
`200`	`203`	`}`
`201`	`204`	`else`
`202`	`205`	`{`
`203`	`206`	`CancellationTokenRegistration registration = new CancellationTokenRegistration();`
`204`	`207`	`if (cancellationToken.CanBeCanceled)`
`205`	`208`	`{`
`206`		`- registration = cancellationToken.Register(CancelIgnoreFailure);`
	`209`	`+ registration = cancellationToken.Register(s => ((DbCommand)s).CancelIgnoreFailure(), this);`
`207`	`210`	`}`
`208`	`211`
`209`	`212`	`try`
`210`	`213`	`{`
`211`	`214`	`return Task.FromResult<DbDataReader>(ExecuteReader(behavior));`
`212`	`215`	`}`
`213`	`216`	`catch (Exception e)`
	`217`	`+ {`
	`218`	`+ return Task.FromException<DbDataReader>(e);`
	`219`	`+ }`
	`220`	`+ finally`
`214`	`221`	`{`
`215`	`222`	`registration.Dispose();`
`216`		`- return ADP.CreatedTaskWithException<DbDataReader>(e);`
`217`	`223`	`}`
`218`	`224`	`}`
`219`	`225`	`}`
`@@ -227,24 +233,27 @@ public virtual Task<object> ExecuteScalarAsync(CancellationToken cancellationTok`
`227`	`233`	`{`
`228`	`234`	`if (cancellationToken.IsCancellationRequested)`
`229`	`235`	`{`
`230`		`- return ADP.CreatedTaskWithCancellation<object>();`
	`236`	`+ return Task.FromCanceled<object>(cancellationToken);`
`231`	`237`	`}`
`232`	`238`	`else`
`233`	`239`	`{`
`234`	`240`	`CancellationTokenRegistration registration = new CancellationTokenRegistration();`
`235`	`241`	`if (cancellationToken.CanBeCanceled)`
`236`	`242`	`{`
`237`		`- registration = cancellationToken.Register(CancelIgnoreFailure);`
	`243`	`+ registration = cancellationToken.Register(s => ((DbCommand)s).CancelIgnoreFailure(), this);`
`238`	`244`	`}`
`239`	`245`
`240`	`246`	`try`
`241`	`247`	`{`
`242`	`248`	`return Task.FromResult<object>(ExecuteScalar());`
`243`	`249`	`}`
`244`	`250`	`catch (Exception e)`
	`251`	`+ {`
	`252`	`+ return Task.FromException<object>(e);`
	`253`	`+ }`
	`254`	`+ finally`
`245`	`255`	`{`
`246`	`256`	`registration.Dispose();`
`247`		`- return ADP.CreatedTaskWithException<object>(e);`
`248`	`257`	`}`
`249`	`258`	`}`
`250`	`259`	`}`
Original file line number	Diff line number	Diff line change
`@@ -115,26 +115,22 @@ public Task OpenAsync()`
`115`	`115`
`116`	`116`	`public virtual Task OpenAsync(CancellationToken cancellationToken)`
`117`	`117`	`{`
`118`		`- TaskCompletionSource<object> taskCompletionSource = new TaskCompletionSource<object>();`
`119`		`-`
`120`	`118`	`if (cancellationToken.IsCancellationRequested)`
`121`	`119`	`{`
`122`		`- taskCompletionSource.SetCanceled();`
	`120`	`+ return Task.FromCanceled(cancellationToken);`
`123`	`121`	`}`
`124`	`122`	`else`
`125`	`123`	`{`
`126`	`124`	`try`
`127`	`125`	`{`
`128`	`126`	`Open();`
`129`		`- taskCompletionSource.SetResult(null);`
	`127`	`+ return Task.CompletedTask;`
`130`	`128`	`}`
`131`	`129`	`catch (Exception e)`
`132`	`130`	`{`
`133`		`- taskCompletionSource.SetException(e);`
	`131`	`+ return Task.FromException(e);`
`134`	`132`	`}`
`135`	`133`	`}`
`136`		`-`
`137`		`- return taskCompletionSource.Task;`
`138`	`134`	`}`
`139`	`135`
`140`	`136`	`public void Dispose()`
Original file line number	Diff line number	Diff line change
`@@ -188,7 +188,7 @@ virtual public Task<T> GetFieldValueAsync<T>(int ordinal, CancellationToken canc`
`188`	`188`	`{`
`189`	`189`	`if (cancellationToken.IsCancellationRequested)`
`190`	`190`	`{`
`191`		`- return ADP.CreatedTaskWithCancellation<T>();`
	`191`	`+ return Task.FromCanceled<T>(cancellationToken);`
`192`	`192`	`}`
`193`	`193`	`else`
`194`	`194`	`{`
`@@ -198,7 +198,7 @@ virtual public Task<T> GetFieldValueAsync<T>(int ordinal, CancellationToken canc`
`198`	`198`	`}`
`199`	`199`	`catch (Exception e)`
`200`	`200`	`{`
`201`		`- return ADP.CreatedTaskWithException<T>(e);`
	`201`	`+ return Task.FromException<T>(e);`
`202`	`202`	`}`
`203`	`203`	`}`
`204`	`204`	`}`
`@@ -216,7 +216,7 @@ virtual public Task<bool> IsDBNullAsync(int ordinal, CancellationToken cancellat`
`216`	`216`	`{`
`217`	`217`	`if (cancellationToken.IsCancellationRequested)`
`218`	`218`	`{`
`219`		`- return ADP.CreatedTaskWithCancellation<bool>();`
	`219`	`+ return Task.FromCanceled<bool>(cancellationToken);`
`220`	`220`	`}`
`221`	`221`	`else`
`222`	`222`	`{`
`@@ -226,7 +226,7 @@ virtual public Task<bool> IsDBNullAsync(int ordinal, CancellationToken cancellat`
`226`	`226`	`}`
`227`	`227`	`catch (Exception e)`
`228`	`228`	`{`
`229`		`- return ADP.CreatedTaskWithException<bool>(e);`
	`229`	`+ return Task.FromException<bool>(e);`
`230`	`230`	`}`
`231`	`231`	`}`
`232`	`232`	`}`
`@@ -244,7 +244,7 @@ virtual public Task<bool> ReadAsync(CancellationToken cancellationToken)`
`244`	`244`	`{`
`245`	`245`	`if (cancellationToken.IsCancellationRequested)`
`246`	`246`	`{`
`247`		`- return ADP.CreatedTaskWithCancellation<bool>();`
	`247`	`+ return Task.FromCanceled<bool>(cancellationToken);`
`248`	`248`	`}`
`249`	`249`	`else`
`250`	`250`	`{`
`@@ -254,7 +254,7 @@ virtual public Task<bool> ReadAsync(CancellationToken cancellationToken)`
`254`	`254`	`}`
`255`	`255`	`catch (Exception e)`
`256`	`256`	`{`
`257`		`- return ADP.CreatedTaskWithException<bool>(e);`
	`257`	`+ return Task.FromException<bool>(e);`
`258`	`258`	`}`
`259`	`259`	`}`
`260`	`260`	`}`
`@@ -268,7 +268,7 @@ virtual public Task<bool> NextResultAsync(CancellationToken cancellationToken)`
`268`	`268`	`{`
`269`	`269`	`if (cancellationToken.IsCancellationRequested)`
`270`	`270`	`{`
`271`		`- return ADP.CreatedTaskWithCancellation<bool>();`
	`271`	`+ return Task.FromCanceled<bool>(cancellationToken);`
`272`	`272`	`}`
`273`	`273`	`else`
`274`	`274`	`{`
`@@ -278,7 +278,7 @@ virtual public Task<bool> NextResultAsync(CancellationToken cancellationToken)`
`278`	`278`	`}`
`279`	`279`	`catch (Exception e)`
`280`	`280`	`{`
`281`		`- return ADP.CreatedTaskWithException<bool>(e);`
	`281`	`+ return Task.FromException<bool>(e);`
`282`	`282`	`}`
`283`	`283`	`}`
`284`	`284`	`}`