From 65d71e6f2389005e7ccd090db51d9e1b5007252f Mon Sep 17 00:00:00 2001
From: Devin Duanne <dduanne@tafs.com>
Date: Thu, 16 Nov 2023 15:23:51 -0600
Subject: [PATCH 1/2] AsyncTaskCodeActivity implements AsyncCodeActivity
 directly

---
 .../Activities/AsyncTaskCodeActivity.cs       | 86 ++++++++++++-------
 1 file changed, 56 insertions(+), 30 deletions(-)

diff --git a/src/UiPath.Workflow/Activities/AsyncTaskCodeActivity.cs b/src/UiPath.Workflow/Activities/AsyncTaskCodeActivity.cs
index 883d5be67..e7632b7cb 100644
--- a/src/UiPath.Workflow/Activities/AsyncTaskCodeActivity.cs
+++ b/src/UiPath.Workflow/Activities/AsyncTaskCodeActivity.cs
@@ -1,68 +1,94 @@
 // This file is part of Core WF which is licensed under the MIT license.
 // See LICENSE file in the project root for full license information.
 
-using System.ComponentModel;
 using System.Threading;
 using System.Threading.Tasks;
 using Nito.AsyncEx.Interop;
 
 namespace System.Activities;
 
-public abstract class AsyncTaskCodeActivity : TaskCodeActivity<object>
+
+/// <summary>
+/// An asynhronous task-based <see cref="AsyncCodeActivity"/>
+/// </summary>
+public abstract class AsyncTaskCodeActivity : AsyncCodeActivity
 {
-    [EditorBrowsable(EditorBrowsableState.Never)]
-    [Browsable(false)]
-    public new object Result { get; set; }
+    protected override IAsyncResult BeginExecute
+    (
+        AsyncCodeActivityContext context,
+        AsyncCallback callback,
+        object state
+    )
+    {
+        var cts = new CancellationTokenSource();
+        context.UserState = cts;
 
-    protected abstract Task ExecuteAsync(AsyncCodeActivityContext context, CancellationToken cancellationToken);
+        var task = ExecuteAsync(context, cts.Token);
 
-    private protected sealed override async Task<object> ExecuteAsyncCore(AsyncCodeActivityContext context,
-        CancellationToken cancellationToken)
-    {
-        await ExecuteAsync(context, cancellationToken);
-        return null;
+        return ApmAsyncFactory.ToBegin(task, callback, state);
     }
-}
 
-public abstract class AsyncTaskCodeActivity<TResult> : TaskCodeActivity<TResult>
-{
-    protected abstract Task<TResult>
-        ExecuteAsync(AsyncCodeActivityContext context, CancellationToken cancellationToken);
+    protected override void EndExecute
+    (
+        AsyncCodeActivityContext context,
+        IAsyncResult result
+    )
+    {
+        using ((CancellationTokenSource)context.UserState)
+        {
+            ((Task)result).Wait();
+        }
+    }
 
-    private protected sealed override Task<TResult> ExecuteAsyncCore(AsyncCodeActivityContext context,
-        CancellationToken cancellationToken)
+    protected override void Cancel(AsyncCodeActivityContext context)
     {
-        return ExecuteAsync(context, cancellationToken);
+        ((CancellationTokenSource)context.UserState).Cancel();
     }
+
+    private protected abstract Task ExecuteAsync
+    (
+        AsyncCodeActivityContext context,
+        CancellationToken cancellationToken
+    );
 }
 
-[EditorBrowsable(EditorBrowsableState.Never)]
-public abstract class TaskCodeActivity<TResult> : AsyncCodeActivity<TResult>
+public abstract class AsyncTaskCodeActivity<TResult> : AsyncCodeActivity<TResult>
 {
-    protected sealed override IAsyncResult BeginExecute(AsyncCodeActivityContext context, AsyncCallback callback,
-        object state)
+    protected sealed override IAsyncResult BeginExecute
+    (
+        AsyncCodeActivityContext context,
+        AsyncCallback callback,
+        object state
+    )
     {
         var cts = new CancellationTokenSource();
         context.UserState = cts;
 
-        var task = ExecuteAsyncCore(context, cts.Token);
+        var task = ExecuteAsync(context, cts.Token);
 
         return ApmAsyncFactory.ToBegin(task, callback, state);
     }
 
-    protected sealed override TResult EndExecute(AsyncCodeActivityContext context, IAsyncResult result)
+    protected sealed override TResult EndExecute
+    (
+        AsyncCodeActivityContext context,
+        IAsyncResult result
+    )
     {
-        using ((CancellationTokenSource) context.UserState)
+        using ((CancellationTokenSource)context.UserState)
         {
-            return ((Task<TResult>) result).Result;
+            return ((Task<TResult>)result).Result;
         }
     }
 
     protected sealed override void Cancel(AsyncCodeActivityContext context)
     {
-        ((CancellationTokenSource) context.UserState).Cancel();
+        ((CancellationTokenSource)context.UserState).Cancel();
     }
 
-    private protected abstract Task<TResult> ExecuteAsyncCore(AsyncCodeActivityContext context,
-        CancellationToken cancellationToken);
+    private protected abstract Task<TResult> ExecuteAsync
+    (
+        AsyncCodeActivityContext context,
+        CancellationToken cancellationToken
+    );
 }

From b077ed5ff733138df64adfc6bf1ec08f4c369006 Mon Sep 17 00:00:00 2001
From: Devin Duanne <dduanne@tafs.com>
Date: Thu, 16 Nov 2023 15:47:07 -0600
Subject: [PATCH 2/2] Fix documentation

---
 .../Activities/AsyncTaskCodeActivity.cs        | 18 +++++++++++++++++-
 1 file changed, 17 insertions(+), 1 deletion(-)

diff --git a/src/UiPath.Workflow/Activities/AsyncTaskCodeActivity.cs b/src/UiPath.Workflow/Activities/AsyncTaskCodeActivity.cs
index e7632b7cb..b911e578a 100644
--- a/src/UiPath.Workflow/Activities/AsyncTaskCodeActivity.cs
+++ b/src/UiPath.Workflow/Activities/AsyncTaskCodeActivity.cs
@@ -9,7 +9,7 @@ namespace System.Activities;
 
 
 /// <summary>
-/// An asynhronous task-based <see cref="AsyncCodeActivity"/>
+/// An asynchronous task-based <see cref="AsyncCodeActivity"/>
 /// </summary>
 public abstract class AsyncTaskCodeActivity : AsyncCodeActivity
 {
@@ -45,6 +45,12 @@ protected override void Cancel(AsyncCodeActivityContext context)
         ((CancellationTokenSource)context.UserState).Cancel();
     }
 
+    /// <summary>
+    /// The operation executed at runtime.
+    /// </summary>
+    /// <param name="context">The context for this activity.</param>
+    /// <param name="cancellationToken">A cancellation token for this operation.</param>
+    /// <returns>A <see cref="Task"/> representing the lifetime of this operation.</returns>
     private protected abstract Task ExecuteAsync
     (
         AsyncCodeActivityContext context,
@@ -52,6 +58,10 @@ CancellationToken cancellationToken
     );
 }
 
+/// <summary>
+/// An asynchronous task-based <see cref="AsyncCodeActivity{TResult}"/>.
+/// </summary>
+/// <typeparam name="TResult">The type of the result this activity returns.</typeparam>
 public abstract class AsyncTaskCodeActivity<TResult> : AsyncCodeActivity<TResult>
 {
     protected sealed override IAsyncResult BeginExecute
@@ -86,6 +96,12 @@ protected sealed override void Cancel(AsyncCodeActivityContext context)
         ((CancellationTokenSource)context.UserState).Cancel();
     }
 
+    /// <summary>
+    /// The operation executed at runtime.
+    /// </summary>
+    /// <param name="context">The context for this activity.</param>
+    /// <param name="cancellationToken">A cancellation token for this operation.</param>
+    /// <returns>A <see cref="Task{TResult}"/> representing the lifetime and containing the result of this operation.</returns>
     private protected abstract Task<TResult> ExecuteAsync
     (
         AsyncCodeActivityContext context,