Unwrap within the task helpers.

Fixes #189.
SignalR · Feb 11, 2012 · 69b9d31 · 69b9d31
1 parent 95a0e04
commit 69b9d31
Show file tree

Hide file tree

Showing 7 changed files with 49 additions and 48 deletions.
diff --git a/SignalR.Client/Connection.cs b/SignalR.Client/Connection.cs
@@ -134,7 +134,6 @@ private Task Negotiate()
 
                         // Get the data and start the transport
                         dataTcs.Task.Then(data => StartTransport(data))
-                                    .FastUnwrap()
                                     .ContinueWith(negotiateTcs);
                     }
                     else

diff --git a/SignalR.ScaleOut/HttpHelper.cs b/SignalR.ScaleOut/HttpHelper.cs
@@ -119,9 +119,7 @@ private static Task<HttpWebResponse> PostInternal(string url, Action<HttpWebRequ
             // Write the post data to the request stream
             return request.GetRequestStreamAsync()
                 .Then(stream => stream.WriteAsync(buffer).Then(() => stream.Close()))
-                .FastUnwrap()
-                .Then(() => request.GetResponseAsync())
-                .FastUnwrap();
+                .Then(() => request.GetResponseAsync());
         }
 
         private static byte[] ProcessPostData(IDictionary<string, string> postData)

diff --git a/SignalR/TaskAsyncHelper.cs b/SignalR/TaskAsyncHelper.cs
@@ -149,10 +149,10 @@ public static Task Then<T1>(this Task task, Action<T1> successor, T1 arg1)
             switch (task.Status)
             {
                 case TaskStatus.Faulted:
-                    return FromError<Task>(task.Exception);
+                    return FromError(task.Exception);
 
                 case TaskStatus.Canceled:
-                    return Canceled<Task>();
+                    return Canceled();
 
                 case TaskStatus.RanToCompletion:
                     return FromMethod(successor, arg1);
@@ -167,10 +167,10 @@ public static Task Then<T1>(this Task task, Action<T1> successor, T1 arg1)
             switch (task.Status)
             {
                 case TaskStatus.Faulted:
-                    return FromError<Task>(task.Exception);
+                    return FromError(task.Exception);
 
                 case TaskStatus.Canceled:
-                    return Canceled<Task>();
+                    return Canceled();
 
                 case TaskStatus.RanToCompletion:
                     return FromMethod(successor, arg1, arg2);
@@ -274,39 +274,41 @@ public static Task Then<T1>(this Task task, Action<T1> successor, T1 arg1)
         }
 
 
-        public static Task<Task> Then(this Task task, Func<Task> successor)
+        public static Task Then(this Task task, Func<Task> successor)
         {
             switch (task.Status)
             {
                 case TaskStatus.Faulted:
-                    return FromError<Task>(task.Exception);
+                    return FromError(task.Exception);
 
                 case TaskStatus.Canceled:
-                    return Canceled<Task>();
+                    return Canceled();
 
                 case TaskStatus.RanToCompletion:
-                    return FromMethod(successor);
+                    return FromMethod(successor).FastUnwrap();
 
                 default:
-                    return TaskRunners<object, Task>.RunTask(task, successor);
+                    return TaskRunners<object, Task>.RunTask(task, successor)
+                                                    .FastUnwrap();
             }
         }
 
-        public static Task<Task<TResult>> Then<TResult>(this Task task, Func<Task<TResult>> successor)
+        public static Task<TResult> Then<TResult>(this Task task, Func<Task<TResult>> successor)
         {
             switch (task.Status)
             {
                 case TaskStatus.Faulted:
-                    return FromError<Task<TResult>>(task.Exception);
+                    return FromError<TResult>(task.Exception);
 
                 case TaskStatus.Canceled:
-                    return Canceled<Task<TResult>>();
+                    return Canceled<TResult>();
 
                 case TaskStatus.RanToCompletion:
-                    return FromMethod(successor);
+                    return FromMethod(successor).FastUnwrap();
 
                 default:
-                    return TaskRunners<object, Task<TResult>>.RunTask(task, successor);
+                    return TaskRunners<object, Task<TResult>>.RunTask(task, successor)
+                                                             .FastUnwrap();
             }
         }
 
@@ -328,75 +330,79 @@ public static Task Then<T>(this Task<T> task, Action<T> successor)
             }
         }
 
-        public static Task<Task> Then<T>(this Task<T> task, Func<T, Task> successor)
+        public static Task Then<T>(this Task<T> task, Func<T, Task> successor)
         {
             switch (task.Status)
             {
                 case TaskStatus.Faulted:
-                    return FromError<Task>(task.Exception);
+                    return FromError(task.Exception);
 
                 case TaskStatus.Canceled:
-                    return Canceled<Task>();
+                    return Canceled();
 
                 case TaskStatus.RanToCompletion:
-                    return FromMethod(successor, task.Result);
+                    return FromMethod(successor, task.Result).FastUnwrap();
 
                 default:
-                    return TaskRunners<T, Task>.RunTask(task, t => successor(t.Result));
+                    return TaskRunners<T, Task>.RunTask(task, t => successor(t.Result))
+                                               .FastUnwrap();
             }
         }
 
-        public static Task<Task> Then<T1>(this Task task, Func<T1, Task> successor, T1 arg1)
+        public static Task Then<T1>(this Task task, Func<T1, Task> successor, T1 arg1)
         {
             switch (task.Status)
             {
                 case TaskStatus.Faulted:
-                    return FromError<Task>(task.Exception);
+                    return FromError(task.Exception);
 
                 case TaskStatus.Canceled:
-                    return Canceled<Task>();
+                    return Canceled();
 
                 case TaskStatus.RanToCompletion:
-                    return FromMethod(successor, arg1);
+                    return FromMethod(successor, arg1).FastUnwrap();
 
                 default:
-                    return GenericDelegates<object, Task, T1, object>.ThenWithArgs(task, successor, arg1);
+                    return GenericDelegates<object, Task, T1, object>.ThenWithArgs(task, successor, arg1)
+                                                                     .FastUnwrap();
             }
         }
 
-        public static Task<Task<TResult>> Then<T, T1, TResult>(this Task<T> task, Func<T, T1, Task<TResult>> successor, T1 arg1)
+        public static Task<TResult> Then<T, T1, TResult>(this Task<T> task, Func<T, T1, Task<TResult>> successor, T1 arg1)
         {
             switch (task.Status)
             {
                 case TaskStatus.Faulted:
-                    return FromError<Task<TResult>>(task.Exception);
+                    return FromError<TResult>(task.Exception);
 
                 case TaskStatus.Canceled:
-                    return Canceled<Task<TResult>>();
+                    return Canceled<TResult>();
 
                 case TaskStatus.RanToCompletion:
-                    return FromMethod(successor, task.Result, arg1);
+                    return FromMethod(successor, task.Result, arg1).FastUnwrap();
 
                 default:
-                    return GenericDelegates<T, Task<TResult>, T1, object>.ThenWithArgs(task, successor, arg1);
+                    return GenericDelegates<T, Task<TResult>, T1, object>.ThenWithArgs(task, successor, arg1)
+                                                                         .FastUnwrap();
             }
         }
 
-        public static Task<Task<T>> Then<T, T1>(this Task<T> task, Func<Task<T>, T1, Task<T>> successor, T1 arg1)
+        public static Task<T> Then<T, T1>(this Task<T> task, Func<Task<T>, T1, Task<T>> successor, T1 arg1)
         {
             switch (task.Status)
             {
                 case TaskStatus.Faulted:
-                    return FromError<Task<T>>(task.Exception);
+                    return FromError<T>(task.Exception);
 
                 case TaskStatus.Canceled:
-                    return Canceled<Task<T>>();
+                    return Canceled<T>();
 
                 case TaskStatus.RanToCompletion:
-                    return FromMethod(successor, task, arg1);
+                    return FromMethod(successor, task, arg1).FastUnwrap();
 
                 default:
-                    return GenericDelegates<T, Task<T>, T1, object>.ThenWithArgs(task, successor, arg1);
+                    return GenericDelegates<T, Task<T>, T1, object>.ThenWithArgs(task, successor, arg1)
+                                                                   .FastUnwrap();
             }
         }
 

diff --git a/SignalR/Transports/ForeverFrameTransport.cs b/SignalR/Transports/ForeverFrameTransport.cs
@@ -54,8 +54,7 @@ protected override Task InitializeResponse(IReceivingConnection connection)
         {
             return base.InitializeResponse(connection)
                 .Then(initScript => Context.Response.WriteAsync(initScript),
-                      _initPrefix + Context.Request.QueryString["frameId"] + _initSuffix)
-                .FastUnwrap();
+                      _initPrefix + Context.Request.QueryString["frameId"] + _initSuffix);
         }
     }
 }
diff --git a/SignalR/Transports/ForeverTransport.cs b/SignalR/Transports/ForeverTransport.cs
@@ -205,7 +205,7 @@ private void ProcessMessagesImpl(TaskCompletionSource<object> taskCompletetionSo
                     // Continue the receive loop
                     return sendTask.Then((conn) => ProcessMessagesImpl(taskCompletetionSource, conn), connection);
                 })
-                .FastUnwrap().ContinueWith(t =>
+                .ContinueWith(t =>
                 {
                     if (t.IsCanceled)
                     {

diff --git a/SignalR/Transports/LongPollingTransport.cs b/SignalR/Transports/LongPollingTransport.cs
@@ -185,8 +185,7 @@ private Task ProcessReceiveRequest(IReceivingConnection connection, Action postR
                 postReceive();
             }
 
-            return receiveTask.Then(response => Send(response))
-                              .FastUnwrap();
+            return receiveTask.Then(response => Send(response));
         }
 
         private PersistentResponse AddTransportData(PersistentResponse response)

diff --git a/SignalR/Transports/ServerSentEventsTransport.cs b/SignalR/Transports/ServerSentEventsTransport.cs
@@ -32,11 +32,11 @@ public override Task Send(PersistentResponse response)
         protected override Task InitializeResponse(IReceivingConnection connection)
         {
             return base.InitializeResponse(connection)
-                .Then(() =>
-                {
-                    Context.Response.ContentType = "text/event-stream";
-                    return Context.Response.WriteAsync("data: initialized\n\n");
-                }).FastUnwrap();
+                       .Then(() =>
+                       {
+                           Context.Response.ContentType = "text/event-stream";
+                           return Context.Response.WriteAsync("data: initialized\n\n");
+                       });
         }
     }
 }