From 71c4beb2c8a27a039608c18c38348ecbbcb4509c Mon Sep 17 00:00:00 2001
From: sakno <roman.sakno@gmail.com>
Date: Thu, 26 Sep 2024 11:59:47 +0300
Subject: [PATCH] Added extra converts to async delegates

---
 src/DotNext.Tests/DelegateHelpersTests.cs | 11 ++++
 src/DotNext/DelegateHelpers.cs            | 73 +++++++++++++++++++++++
 2 files changed, 84 insertions(+)

diff --git a/src/DotNext.Tests/DelegateHelpersTests.cs b/src/DotNext.Tests/DelegateHelpersTests.cs
index eb29ba126..108a90123 100644
--- a/src/DotNext.Tests/DelegateHelpersTests.cs
+++ b/src/DotNext.Tests/DelegateHelpersTests.cs
@@ -543,6 +543,17 @@ public static async Task ToAsync4()
         func = new Func<int, int, int>(static (_, _) => throw new Exception()).ToAsync();
         await ThrowsAsync<Exception>(func.Invoke(42, 42, new(canceled: false)).AsTask);
     }
+    
+    [Fact]
+    public static async Task ToAsync5()
+    {
+        var func = Func.Identity<int>().ToAsync();
+        Equal(42, await func.Invoke(42, new(canceled: false)));
+        True(func.Invoke(42, new(canceled: true)).IsCanceled);
+
+        func = new Func<int, int>(static _ => throw new Exception()).ToAsync();
+        await ThrowsAsync<Exception>(func.Invoke(42, new(canceled: false)).AsTask);
+    }
 
     [Fact]
     public static void HideReturnValue1()
diff --git a/src/DotNext/DelegateHelpers.cs b/src/DotNext/DelegateHelpers.cs
index 8c9dc7aa4..aa65a3b24 100644
--- a/src/DotNext/DelegateHelpers.cs
+++ b/src/DotNext/DelegateHelpers.cs
@@ -126,6 +126,43 @@ private static ValueTask Invoke<T>(this Action<T> action, T arg, CancellationTok
         return task;
     }
     
+    /// <summary>
+    /// Converts function to async delegate.
+    /// </summary>
+    /// <param name="action">Synchronous function.</param>
+    /// <typeparam name="T">The type of the argument to be passed to the action.</typeparam>
+    /// <typeparam name="TResult">The type of the return value.</typeparam>
+    /// <returns>The asynchronous function that wraps <paramref name="action"/>.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="action"/> is <see langword="null"/>.</exception>
+    public static Func<T, CancellationToken, ValueTask<TResult>> ToAsync<T, TResult>(this Func<T, TResult> action)
+    {
+        ArgumentNullException.ThrowIfNull(action);
+
+        return action.Invoke;
+    }
+
+    private static ValueTask<TResult> Invoke<T, TResult>(this Func<T, TResult> action, T arg, CancellationToken token)
+    {
+        ValueTask<TResult> task;
+        if (token.IsCancellationRequested)
+        {
+            task = ValueTask.FromCanceled<TResult>(token);
+        }
+        else
+        {
+            try
+            {
+                task = new(action.Invoke(arg));
+            }
+            catch (Exception e)
+            {
+                task = ValueTask.FromException<TResult>(e);
+            }
+        }
+
+        return task;
+    }
+    
     /// <summary>
     /// Converts action to async delegate.
     /// </summary>
@@ -161,6 +198,42 @@ private static ValueTask Invoke(this Action action, CancellationToken token)
 
         return task;
     }
+    
+    /// <summary>
+    /// Converts function to async delegate.
+    /// </summary>
+    /// <typeparam name="TResult">The type of the return value.</typeparam>
+    /// <param name="func">Synchronous function.</param>
+    /// <returns>The asynchronous function that wraps <paramref name="func"/>.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="func"/> is <see langword="null"/>.</exception>
+    public static Func<CancellationToken, ValueTask<TResult>> ToAsync<TResult>(this Func<TResult> func)
+    {
+        ArgumentNullException.ThrowIfNull(func);
+
+        return func.Invoke;
+    }
+
+    private static ValueTask<TResult> Invoke<TResult>(this Func<TResult> func, CancellationToken token)
+    {
+        ValueTask<TResult> task;
+        if (token.IsCancellationRequested)
+        {
+            task = ValueTask.FromCanceled<TResult>(token);
+        }
+        else
+        {
+            try
+            {
+                task = new(func.Invoke());
+            }
+            catch (Exception e)
+            {
+                task = ValueTask.FromException<TResult>(e);
+            }
+        }
+
+        return task;
+    }
 
     /// <summary>
     /// Converts action to async delegate.