Added SuspendException overload that returns Result<T> (#258)

Author: sakno

src/DotNext.Tests/Threading/Tasks/ConversionTests.cs

@@ -46,6 +46,10 @@ public static async Task SuspendException()
     {
         await Task.FromException(new Exception()).SuspendException();
         await ValueTask.FromException(new Exception()).SuspendException();
+
+        var result = await Task.FromException<int>(new ArithmeticException()).SuspendException();
+        False(result.IsSuccessful);
+        IsType<ArithmeticException>(result.Error);
     }
 
     [Fact]

src/DotNext/Runtime/CompilerServices/SuspendedExceptionTaskAwaitable.cs

@@ -97,7 +97,7 @@ public void GetResult()
 }
 
 /// <summary>
-/// Represents awaitable object that can suspend exception raised by the underlying task.
+/// Represents awaitable object that can suspend the exception raised by the underlying task.
 /// </summary>
 /// <typeparam name="TArg">The type of the argument to be passed to the exception filter.</typeparam>
 [StructLayout(LayoutKind.Auto)]
@@ -187,4 +187,80 @@ public void GetResult()
             }
         }
     }
+}
+
+/// <summary>
+/// Represents awaitable object that can suspend the exception raised by the underlying task.
+/// </summary>
+/// <typeparam name="T">The type of the task.</typeparam>
+[StructLayout(LayoutKind.Auto)]
+public readonly struct AwaitableResult<T>
+{
+    private readonly Task<T> task;
+
+    internal AwaitableResult(Task<T> task) => this.task = task;
+    
+    internal bool ContinueOnCapturedContext
+    {
+        get;
+        init;
+    }
+    
+    /// <summary>
+    /// Configures an awaiter for this value.
+    /// </summary>
+    /// <param name="continueOnCapturedContext">
+    /// <see langword="true"/> to attempt to marshal the continuation back to the captured context;
+    /// otherwise, <see langword="false"/>.
+    /// </param>
+    /// <returns>The configured object.</returns>
+    public AwaitableResult<T> ConfigureAwait(bool continueOnCapturedContext)
+        => this with { ContinueOnCapturedContext = continueOnCapturedContext };
+
+    /// <summary>
+    /// Gets the awaiter for this object.
+    /// </summary>
+    /// <returns>The awaiter for this object.</returns>
+    public Awaiter GetAwaiter() => new(task, ContinueOnCapturedContext);
+
+    /// <summary>
+    /// Represents the awaiter that suspends exception.
+    /// </summary>
+    [StructLayout(LayoutKind.Auto)]
+    public readonly struct Awaiter : ICriticalNotifyCompletion
+    {
+        private readonly ConfiguredTaskAwaitable<T>.ConfiguredTaskAwaiter awaiter;
+
+        internal Awaiter(Task<T> task, bool continueOnCapturedContext)
+            => awaiter = task.ConfigureAwait(continueOnCapturedContext).GetAwaiter();
+
+        /// <summary>
+        /// Gets a value indicating that <see cref="AwaitableResult{T}"/> has completed.
+        /// </summary>
+        public bool IsCompleted => awaiter.IsCompleted;
+
+        /// <inheritdoc/>
+        public void OnCompleted(Action action) => awaiter.OnCompleted(action);
+
+        /// <inheritdoc/>
+        public void UnsafeOnCompleted(Action action) => awaiter.UnsafeOnCompleted(action);
+
+        /// <summary>
+        /// Obtains a result of asynchronous operation, and suspends exception if needed.
+        /// </summary>
+        public Result<T> GetResult()
+        {
+            Result<T> result;
+            try
+            {
+                result = new(awaiter.GetResult());
+            }
+            catch (Exception e)
+            {
+                result = new(e);
+            }
+
+            return result;
+        }
+    }
 }

src/DotNext/Threading/Tasks/Conversion.cs

@@ -67,6 +67,14 @@ public static async Task<TOutput> Convert<TInput, TOutput>(this Task<TInput> tas
     [RequiresUnreferencedCode("Runtime binding may be incompatible with IL trimming")]
     public static DynamicTaskAwaitable AsDynamic(this Task task) => new(task);
 
+    /// <summary>
+    /// Returns a task that never throws an exception.
+    /// </summary>
+    /// <param name="task">The task to convert.</param>
+    /// <typeparam name="T">The type of the task.</typeparam>
+    /// <returns>The task that never throws an exception. Instead, the <see cref="Result{T}"/> contains an exception.</returns>
+    public static AwaitableResult<T> SuspendException<T>(this Task<T> task) => new(task);
+
     /// <summary>
     /// Suspends the exception that can be raised by the task.
     /// </summary>