updated code for cancellation token disposal

michael.hallett · michael.hallett · commit 7350717bed8c · 2015-08-04T17:08:01.000-07:00
diff --git a/RestSharp/RestClient.Async.cs b/RestSharp/RestClient.Async.cs
@@ -38,7 +38,7 @@ public virtual RestRequestAsyncHandle ExecuteAsync(IRestRequest request,
 #if PocketPC
             string method = request.Method.ToString();
 #else
-            string method = Enum.GetName(typeof (Method), request.Method);
+            string method = Enum.GetName(typeof(Method), request.Method);
 #endif
 
             switch (request.Method)
@@ -47,10 +47,10 @@ public virtual RestRequestAsyncHandle ExecuteAsync(IRestRequest request,
                 case Method.PATCH:
                 case Method.POST:
                 case Method.PUT:
-                    return ExecuteAsync(request, callback, method, DoAsPostAsync);
+                    return this.ExecuteAsync(request, callback, method, DoAsPostAsync);
 
                 default:
-                    return ExecuteAsync(request, callback, method, DoAsGetAsync);
+                    return this.ExecuteAsync(request, callback, method, DoAsGetAsync);
             }
         }
 
@@ -63,7 +63,7 @@ public virtual RestRequestAsyncHandle ExecuteAsync(IRestRequest request,
         public virtual RestRequestAsyncHandle ExecuteAsyncGet(IRestRequest request,
             Action<IRestResponse, RestRequestAsyncHandle> callback, string httpMethod)
         {
-            return ExecuteAsync(request, callback, httpMethod, DoAsGetAsync);
+            return this.ExecuteAsync(request, callback, httpMethod, DoAsGetAsync);
         }
 
         /// <summary>
@@ -76,25 +76,25 @@ public virtual RestRequestAsyncHandle ExecuteAsyncPost(IRestRequest request,
             Action<IRestResponse, RestRequestAsyncHandle> callback, string httpMethod)
         {
             request.Method = Method.POST; // Required by RestClient.BuildUri... 
-            return ExecuteAsync(request, callback, httpMethod, DoAsPostAsync);
+            return this.ExecuteAsync(request, callback, httpMethod, DoAsPostAsync);
         }
 
         private RestRequestAsyncHandle ExecuteAsync(IRestRequest request,
             Action<IRestResponse, RestRequestAsyncHandle> callback, string httpMethod,
             Func<IHttp, Action<HttpResponse>, string, HttpWebRequest> getWebRequest)
         {
-            var http = HttpFactory.Create();
+            var http = this.HttpFactory.Create();
 
-            AuthenticateIfNeeded(this, request);
+            this.AuthenticateIfNeeded(this, request);
 
-            ConfigureHttp(request, http);
+            this.ConfigureHttp(request, http);
 
             var asyncHandle = new RestRequestAsyncHandle();
 
-            Action<HttpResponse> response_cb = r => ProcessResponse(request, r, asyncHandle, callback);
+            Action<HttpResponse> response_cb = r => this.ProcessResponse(request, r, asyncHandle, callback);
 
 #if !PocketPC
-            if (UseSynchronizationContext && SynchronizationContext.Current != null)
+            if (this.UseSynchronizationContext && SynchronizationContext.Current != null)
             {
                 var ctx = SynchronizationContext.Current;
                 var cb = response_cb;
@@ -133,8 +133,8 @@ private void ProcessResponse(IRestRequest request, HttpResponse httpResponse, Re
         public virtual RestRequestAsyncHandle ExecuteAsync<T>(IRestRequest request,
             Action<IRestResponse<T>, RestRequestAsyncHandle> callback)
         {
-            return ExecuteAsync(request,
-                (response, asyncHandle) => DeserializeResponse(request, callback, response, asyncHandle));
+            return this.ExecuteAsync(request,
+                (response, asyncHandle) => this.DeserializeResponse(request, callback, response, asyncHandle));
         }
 
         /// <summary>
@@ -147,8 +147,8 @@ public virtual RestRequestAsyncHandle ExecuteAsync<T>(IRestRequest request,
         public virtual RestRequestAsyncHandle ExecuteAsyncGet<T>(IRestRequest request,
             Action<IRestResponse<T>, RestRequestAsyncHandle> callback, string httpMethod)
         {
-            return ExecuteAsyncGet(request,
-                (response, asyncHandle) => DeserializeResponse(request, callback, response, asyncHandle), httpMethod);
+            return this.ExecuteAsyncGet(request,
+                (response, asyncHandle) => this.DeserializeResponse(request, callback, response, asyncHandle), httpMethod);
         }
 
         /// <summary>
@@ -161,8 +161,8 @@ public virtual RestRequestAsyncHandle ExecuteAsyncGet<T>(IRestRequest request,
         public virtual RestRequestAsyncHandle ExecuteAsyncPost<T>(IRestRequest request,
             Action<IRestResponse<T>, RestRequestAsyncHandle> callback, string httpMethod)
         {
-            return ExecuteAsyncPost(request,
-                (response, asyncHandle) => DeserializeResponse(request, callback, response, asyncHandle), httpMethod);
+            return this.ExecuteAsyncPost(request,
+                (response, asyncHandle) => this.DeserializeResponse(request, callback, response, asyncHandle), httpMethod);
         }
 
         private void DeserializeResponse<T>(IRestRequest request,
@@ -173,7 +173,7 @@ private void DeserializeResponse<T>(IRestRequest request,
 
             try
             {
-                restResponse = Deserialize<T>(request, response);
+                restResponse = this.Deserialize<T>(request, response);
             }
             catch (Exception ex)
             {
@@ -190,14 +190,14 @@ private void DeserializeResponse<T>(IRestRequest request,
         }
 
 #if NET4 || MONODROID || MONOTOUCH || WP8
-    /// <summary>
-    /// Executes a GET-style request asynchronously, authenticating if needed
-    /// </summary>
-    /// <typeparam name="T">Target deserialization type</typeparam>
-    /// <param name="request">Request to be executed</param>
+        /// <summary>
+        /// Executes a GET-style request asynchronously, authenticating if needed
+        /// </summary>
+        /// <typeparam name="T">Target deserialization type</typeparam>
+        /// <param name="request">Request to be executed</param>
         public virtual Task<IRestResponse<T>> ExecuteGetTaskAsync<T>(IRestRequest request)
         {
-            return ExecuteGetTaskAsync<T>(request, CancellationToken.None);
+            return this.ExecuteGetTaskAsync<T>(request, CancellationToken.None);
         }
 
         /// <summary>
@@ -214,7 +214,7 @@ public virtual Task<IRestResponse<T>> ExecuteGetTaskAsync<T>(IRestRequest reques
             }
 
             request.Method = Method.GET;
-            return ExecuteTaskAsync<T>(request, token);
+            return this.ExecuteTaskAsync<T>(request, token);
         }
 
         /// <summary>
@@ -224,7 +224,7 @@ public virtual Task<IRestResponse<T>> ExecuteGetTaskAsync<T>(IRestRequest reques
         /// <param name="request">Request to be executed</param>
         public virtual Task<IRestResponse<T>> ExecutePostTaskAsync<T>(IRestRequest request)
         {
-            return ExecutePostTaskAsync<T>(request, CancellationToken.None);
+            return this.ExecutePostTaskAsync<T>(request, CancellationToken.None);
         }
 
         /// <summary>
@@ -241,7 +241,7 @@ public virtual Task<IRestResponse<T>> ExecutePostTaskAsync<T>(IRestRequest reque
             }
 
             request.Method = Method.POST;
-            return ExecuteTaskAsync<T>(request, token);
+            return this.ExecuteTaskAsync<T>(request, token);
         }
 
         /// <summary>
@@ -251,7 +251,7 @@ public virtual Task<IRestResponse<T>> ExecutePostTaskAsync<T>(IRestRequest reque
         /// <param name="request">Request to be executed</param>
         public virtual Task<IRestResponse<T>> ExecuteTaskAsync<T>(IRestRequest request)
         {
-            return ExecuteTaskAsync<T>(request, CancellationToken.None);
+            return this.ExecuteTaskAsync<T>(request, CancellationToken.None);
         }
 
         /// <summary>
@@ -271,7 +271,7 @@ public virtual Task<IRestResponse<T>> ExecuteTaskAsync<T>(IRestRequest request,
 
             try
             {
-                var async = ExecuteAsync<T>(request, (response, _) =>
+                var async = this.ExecuteAsync<T>(request, (response, _) =>
                     {
                         if (token.IsCancellationRequested)
                         {
@@ -284,14 +284,14 @@ public virtual Task<IRestResponse<T>> ExecuteTaskAsync<T>(IRestRequest request,
                         }
                     });
 
-                token.Register(() =>
+                var registration = token.Register(() =>
                     {
                         async.Abort();
                         taskCompletionSource.TrySetCanceled();
                     });
 
 #if !WINDOWS_PHONE
-                taskCompletionSource.Task.ContinueWith(t => t.Dispose(), token);
+                taskCompletionSource.Task.ContinueWith(t => registration.Dispose(), token);
 #endif
             }
             catch (Exception ex)
@@ -308,7 +308,7 @@ public virtual Task<IRestResponse<T>> ExecuteTaskAsync<T>(IRestRequest request,
         /// <param name="request">Request to be executed</param>
         public virtual Task<IRestResponse> ExecuteTaskAsync(IRestRequest request)
         {
-            return ExecuteTaskAsync(request, CancellationToken.None);
+            return this.ExecuteTaskAsync(request, CancellationToken.None);
         }
 
         /// <summary>
@@ -333,7 +333,7 @@ public virtual Task<IRestResponse> ExecuteGetTaskAsync(IRestRequest request, Can
             }
 
             request.Method = Method.GET;
-            return ExecuteTaskAsync(request, token);
+            return this.ExecuteTaskAsync(request, token);
         }
 
         /// <summary>
@@ -358,7 +358,7 @@ public virtual Task<IRestResponse> ExecutePostTaskAsync(IRestRequest request, Ca
             }
 
             request.Method = Method.POST;
-            return ExecuteTaskAsync(request, token);
+            return this.ExecuteTaskAsync(request, token);
         }
 
         /// <summary>
@@ -390,14 +390,14 @@ public virtual Task<IRestResponse> ExecuteTaskAsync(IRestRequest request, Cancel
                         }
                     });
 
-                token.Register(() =>
-                    {
-                        async.Abort();
-                        taskCompletionSource.TrySetCanceled();
-                    });
+                var registration = token.Register(() =>
+                                                  {
+                                                      async.Abort();
+                                                      taskCompletionSource.TrySetCanceled();
+                                                  });
 
 #if !WINDOWS_PHONE
-                taskCompletionSource.Task.ContinueWith(t => t.Dispose(), token);
+                taskCompletionSource.Task.ContinueWith(t => registration.Dispose(), token);
 #endif
             }
             catch (Exception ex)

Original file line number	Diff line number	Diff line change
`@@ -38,7 +38,7 @@ public virtual RestRequestAsyncHandle ExecuteAsync(IRestRequest request,`
`38`	`38`	`#if PocketPC`
`39`	`39`	`string method = request.Method.ToString();`
`40`	`40`	`#else`
`41`		`- string method = Enum.GetName(typeof (Method), request.Method);`
	`41`	`+ string method = Enum.GetName(typeof(Method), request.Method);`
`42`	`42`	`#endif`
`43`	`43`
`44`	`44`	`switch (request.Method)`
`@@ -47,10 +47,10 @@ public virtual RestRequestAsyncHandle ExecuteAsync(IRestRequest request,`
`47`	`47`	`case Method.PATCH:`
`48`	`48`	`case Method.POST:`
`49`	`49`	`case Method.PUT:`
`50`		`- return ExecuteAsync(request, callback, method, DoAsPostAsync);`
	`50`	`+ return this.ExecuteAsync(request, callback, method, DoAsPostAsync);`
`51`	`51`
`52`	`52`	`default:`
`53`		`- return ExecuteAsync(request, callback, method, DoAsGetAsync);`
	`53`	`+ return this.ExecuteAsync(request, callback, method, DoAsGetAsync);`
`54`	`54`	`}`
`55`	`55`	`}`
`56`	`56`
`@@ -63,7 +63,7 @@ public virtual RestRequestAsyncHandle ExecuteAsync(IRestRequest request,`
`63`	`63`	`public virtual RestRequestAsyncHandle ExecuteAsyncGet(IRestRequest request,`
`64`	`64`	`Action<IRestResponse, RestRequestAsyncHandle> callback, string httpMethod)`
`65`	`65`	`{`
`66`		`- return ExecuteAsync(request, callback, httpMethod, DoAsGetAsync);`
	`66`	`+ return this.ExecuteAsync(request, callback, httpMethod, DoAsGetAsync);`
`67`	`67`	`}`
`68`	`68`
`69`	`69`	`/// <summary>`
`@@ -76,25 +76,25 @@ public virtual RestRequestAsyncHandle ExecuteAsyncPost(IRestRequest request,`
`76`	`76`	`Action<IRestResponse, RestRequestAsyncHandle> callback, string httpMethod)`
`77`	`77`	`{`
`78`	`78`	`request.Method = Method.POST; // Required by RestClient.BuildUri...`
`79`		`- return ExecuteAsync(request, callback, httpMethod, DoAsPostAsync);`
	`79`	`+ return this.ExecuteAsync(request, callback, httpMethod, DoAsPostAsync);`
`80`	`80`	`}`
`81`	`81`
`82`	`82`	`private RestRequestAsyncHandle ExecuteAsync(IRestRequest request,`
`83`	`83`	`Action<IRestResponse, RestRequestAsyncHandle> callback, string httpMethod,`
`84`	`84`	`Func<IHttp, Action<HttpResponse>, string, HttpWebRequest> getWebRequest)`
`85`	`85`	`{`
`86`		`- var http = HttpFactory.Create();`
	`86`	`+ var http = this.HttpFactory.Create();`
`87`	`87`
`88`		`- AuthenticateIfNeeded(this, request);`
	`88`	`+ this.AuthenticateIfNeeded(this, request);`
`89`	`89`
`90`		`- ConfigureHttp(request, http);`
	`90`	`+ this.ConfigureHttp(request, http);`
`91`	`91`
`92`	`92`	`var asyncHandle = new RestRequestAsyncHandle();`
`93`	`93`
`94`		`- Action<HttpResponse> response_cb = r => ProcessResponse(request, r, asyncHandle, callback);`
	`94`	`+ Action<HttpResponse> response_cb = r => this.ProcessResponse(request, r, asyncHandle, callback);`
`95`	`95`
`96`	`96`	`#if !PocketPC`
`97`		`- if (UseSynchronizationContext && SynchronizationContext.Current != null)`
	`97`	`+ if (this.UseSynchronizationContext && SynchronizationContext.Current != null)`
`98`	`98`	`{`
`99`	`99`	`var ctx = SynchronizationContext.Current;`
`100`	`100`	`var cb = response_cb;`
`@@ -133,8 +133,8 @@ private void ProcessResponse(IRestRequest request, HttpResponse httpResponse, Re`
`133`	`133`	`public virtual RestRequestAsyncHandle ExecuteAsync<T>(IRestRequest request,`
`134`	`134`	`Action<IRestResponse<T>, RestRequestAsyncHandle> callback)`
`135`	`135`	`{`
`136`		`- return ExecuteAsync(request,`
`137`		`- (response, asyncHandle) => DeserializeResponse(request, callback, response, asyncHandle));`
	`136`	`+ return this.ExecuteAsync(request,`
	`137`	`+ (response, asyncHandle) => this.DeserializeResponse(request, callback, response, asyncHandle));`
`138`	`138`	`}`
`139`	`139`
`140`	`140`	`/// <summary>`
`@@ -147,8 +147,8 @@ public virtual RestRequestAsyncHandle ExecuteAsync<T>(IRestRequest request,`
`147`	`147`	`public virtual RestRequestAsyncHandle ExecuteAsyncGet<T>(IRestRequest request,`
`148`	`148`	`Action<IRestResponse<T>, RestRequestAsyncHandle> callback, string httpMethod)`
`149`	`149`	`{`
`150`		`- return ExecuteAsyncGet(request,`
`151`		`- (response, asyncHandle) => DeserializeResponse(request, callback, response, asyncHandle), httpMethod);`
	`150`	`+ return this.ExecuteAsyncGet(request,`
	`151`	`+ (response, asyncHandle) => this.DeserializeResponse(request, callback, response, asyncHandle), httpMethod);`
`152`	`152`	`}`
`153`	`153`
`154`	`154`	`/// <summary>`
`@@ -161,8 +161,8 @@ public virtual RestRequestAsyncHandle ExecuteAsyncGet<T>(IRestRequest request,`
`161`	`161`	`public virtual RestRequestAsyncHandle ExecuteAsyncPost<T>(IRestRequest request,`
`162`	`162`	`Action<IRestResponse<T>, RestRequestAsyncHandle> callback, string httpMethod)`
`163`	`163`	`{`
`164`		`- return ExecuteAsyncPost(request,`
`165`		`- (response, asyncHandle) => DeserializeResponse(request, callback, response, asyncHandle), httpMethod);`
	`164`	`+ return this.ExecuteAsyncPost(request,`
	`165`	`+ (response, asyncHandle) => this.DeserializeResponse(request, callback, response, asyncHandle), httpMethod);`
`166`	`166`	`}`
`167`	`167`
`168`	`168`	`private void DeserializeResponse<T>(IRestRequest request,`
`@@ -173,7 +173,7 @@ private void DeserializeResponse<T>(IRestRequest request,`
`173`	`173`
`174`	`174`	`try`
`175`	`175`	`{`
`176`		`- restResponse = Deserialize<T>(request, response);`
	`176`	`+ restResponse = this.Deserialize<T>(request, response);`
`177`	`177`	`}`
`178`	`178`	`catch (Exception ex)`
`179`	`179`	`{`
`@@ -190,14 +190,14 @@ private void DeserializeResponse<T>(IRestRequest request,`
`190`	`190`	`}`
`191`	`191`
`192`	`192`	`#if NET4 \|\| MONODROID \|\| MONOTOUCH \|\| WP8`
`193`		`- /// <summary>`
`194`		`- /// Executes a GET-style request asynchronously, authenticating if needed`
`195`		`- /// </summary>`
`196`		`- /// <typeparam name="T">Target deserialization type</typeparam>`
`197`		`- /// <param name="request">Request to be executed</param>`
	`193`	`+ /// <summary>`
	`194`	`+ /// Executes a GET-style request asynchronously, authenticating if needed`
	`195`	`+ /// </summary>`
	`196`	`+ /// <typeparam name="T">Target deserialization type</typeparam>`
	`197`	`+ /// <param name="request">Request to be executed</param>`
`198`	`198`	`public virtual Task<IRestResponse<T>> ExecuteGetTaskAsync<T>(IRestRequest request)`
`199`	`199`	`{`
`200`		`- return ExecuteGetTaskAsync<T>(request, CancellationToken.None);`
	`200`	`+ return this.ExecuteGetTaskAsync<T>(request, CancellationToken.None);`
`201`	`201`	`}`
`202`	`202`
`203`	`203`	`/// <summary>`
`@@ -214,7 +214,7 @@ public virtual Task<IRestResponse<T>> ExecuteGetTaskAsync<T>(IRestRequest reques`
`214`	`214`	`}`
`215`	`215`
`216`	`216`	`request.Method = Method.GET;`
`217`		`- return ExecuteTaskAsync<T>(request, token);`
	`217`	`+ return this.ExecuteTaskAsync<T>(request, token);`
`218`	`218`	`}`
`219`	`219`
`220`	`220`	`/// <summary>`
`@@ -224,7 +224,7 @@ public virtual Task<IRestResponse<T>> ExecuteGetTaskAsync<T>(IRestRequest reques`
`224`	`224`	`/// <param name="request">Request to be executed</param>`
`225`	`225`	`public virtual Task<IRestResponse<T>> ExecutePostTaskAsync<T>(IRestRequest request)`
`226`	`226`	`{`
`227`		`- return ExecutePostTaskAsync<T>(request, CancellationToken.None);`
	`227`	`+ return this.ExecutePostTaskAsync<T>(request, CancellationToken.None);`
`228`	`228`	`}`
`229`	`229`
`230`	`230`	`/// <summary>`
`@@ -241,7 +241,7 @@ public virtual Task<IRestResponse<T>> ExecutePostTaskAsync<T>(IRestRequest reque`
`241`	`241`	`}`
`242`	`242`
`243`	`243`	`request.Method = Method.POST;`
`244`		`- return ExecuteTaskAsync<T>(request, token);`
	`244`	`+ return this.ExecuteTaskAsync<T>(request, token);`
`245`	`245`	`}`
`246`	`246`
`247`	`247`	`/// <summary>`
`@@ -251,7 +251,7 @@ public virtual Task<IRestResponse<T>> ExecutePostTaskAsync<T>(IRestRequest reque`
`251`	`251`	`/// <param name="request">Request to be executed</param>`
`252`	`252`	`public virtual Task<IRestResponse<T>> ExecuteTaskAsync<T>(IRestRequest request)`
`253`	`253`	`{`
`254`		`- return ExecuteTaskAsync<T>(request, CancellationToken.None);`
	`254`	`+ return this.ExecuteTaskAsync<T>(request, CancellationToken.None);`
`255`	`255`	`}`
`256`	`256`
`257`	`257`	`/// <summary>`
`@@ -271,7 +271,7 @@ public virtual Task<IRestResponse<T>> ExecuteTaskAsync<T>(IRestRequest request,`
`271`	`271`
`272`	`272`	`try`
`273`	`273`	`{`
`274`		`- var async = ExecuteAsync<T>(request, (response, _) =>`
	`274`	`+ var async = this.ExecuteAsync<T>(request, (response, _) =>`
`275`	`275`	`{`
`276`	`276`	`if (token.IsCancellationRequested)`
`277`	`277`	`{`
`@@ -284,14 +284,14 @@ public virtual Task<IRestResponse<T>> ExecuteTaskAsync<T>(IRestRequest request,`
`284`	`284`	`}`
`285`	`285`	`});`
`286`	`286`
`287`		`- token.Register(() =>`
	`287`	`+ var registration = token.Register(() =>`
`288`	`288`	`{`
`289`	`289`	`async.Abort();`
`290`	`290`	`taskCompletionSource.TrySetCanceled();`
`291`	`291`	`});`
`292`	`292`
`293`	`293`	`#if !WINDOWS_PHONE`
`294`		`- taskCompletionSource.Task.ContinueWith(t => t.Dispose(), token);`
	`294`	`+ taskCompletionSource.Task.ContinueWith(t => registration.Dispose(), token);`
`295`	`295`	`#endif`
`296`	`296`	`}`
`297`	`297`	`catch (Exception ex)`
`@@ -308,7 +308,7 @@ public virtual Task<IRestResponse<T>> ExecuteTaskAsync<T>(IRestRequest request,`
`308`	`308`	`/// <param name="request">Request to be executed</param>`
`309`	`309`	`public virtual Task<IRestResponse> ExecuteTaskAsync(IRestRequest request)`
`310`	`310`	`{`
`311`		`- return ExecuteTaskAsync(request, CancellationToken.None);`
	`311`	`+ return this.ExecuteTaskAsync(request, CancellationToken.None);`
`312`	`312`	`}`
`313`	`313`
`314`	`314`	`/// <summary>`
`@@ -333,7 +333,7 @@ public virtual Task<IRestResponse> ExecuteGetTaskAsync(IRestRequest request, Can`
`333`	`333`	`}`
`334`	`334`
`335`	`335`	`request.Method = Method.GET;`
`336`		`- return ExecuteTaskAsync(request, token);`
	`336`	`+ return this.ExecuteTaskAsync(request, token);`
`337`	`337`	`}`
`338`	`338`
`339`	`339`	`/// <summary>`
`@@ -358,7 +358,7 @@ public virtual Task<IRestResponse> ExecutePostTaskAsync(IRestRequest request, Ca`
`358`	`358`	`}`
`359`	`359`
`360`	`360`	`request.Method = Method.POST;`
`361`		`- return ExecuteTaskAsync(request, token);`
	`361`	`+ return this.ExecuteTaskAsync(request, token);`
`362`	`362`	`}`
`363`	`363`
`364`	`364`	`/// <summary>`
`@@ -390,14 +390,14 @@ public virtual Task<IRestResponse> ExecuteTaskAsync(IRestRequest request, Cancel`
`390`	`390`	`}`
`391`	`391`	`});`
`392`	`392`
`393`		`- token.Register(() =>`
`394`		`- {`
`395`		`- async.Abort();`
`396`		`- taskCompletionSource.TrySetCanceled();`
`397`		`- });`
	`393`	`+ var registration = token.Register(() =>`
	`394`	`+ {`
	`395`	`+ async.Abort();`
	`396`	`+ taskCompletionSource.TrySetCanceled();`
	`397`	`+ });`
`398`	`398`
`399`	`399`	`#if !WINDOWS_PHONE`
`400`		`- taskCompletionSource.Task.ContinueWith(t => t.Dispose(), token);`
	`400`	`+ taskCompletionSource.Task.ContinueWith(t => registration.Dispose(), token);`
`401`	`401`	`#endif`
`402`	`402`	`}`
`403`	`403`	`catch (Exception ex)`