Cleanups to the code as requested

Author: kendallb

src/Renci.SshNet.Tests/Classes/SshCommandTest.cs

@@ -576,7 +576,7 @@ public async Task Test_Execute_Invalid_CommandAsync()
                 await client.ConnectAsync(default);
 
                 var cmd = client.CreateCommand(";");
-                await cmd.ExecuteAsync();
+                await cmd.ExecuteAsync(default);
                 var error = await new StreamReader(cmd.ExtendedOutputStream).ReadToEndAsync();
                 if (!string.IsNullOrEmpty(error))
                 {

src/Renci.SshNet/AsyncExtensions.cs

@@ -17,97 +17,34 @@ public static class AsyncExtensions
         /// <param name="asyncResult">Async result we need to await on</param>
         /// <param name="endMethod">End method for the async function</param>
         /// <param name="cancellationToken">The <see cref="CancellationToken"/> to observe.</param>
-        /// <param name="factory">Optional task factory to use</param>
-        /// <param name="creationOptions">Optional task creation options to use</param>
-        /// <param name="scheduler">Optional task schedule to use</param>
-        internal static async Task FromAsync(
-            IAsyncResult asyncResult,
-            Action<IAsyncResult> endMethod,
-            CancellationToken cancellationToken,
-            TaskFactory factory,
-            TaskCreationOptions creationOptions,
-            TaskScheduler scheduler)
-        {
-            // Execute the task via APM
-            factory = factory ?? Task.Factory;
-            scheduler = scheduler ?? factory.Scheduler ?? TaskScheduler.Current;
-            var asyncTask = factory.FromAsync(asyncResult, endMethod, creationOptions, scheduler);
-
-            // Create another task that completes as soon as cancellation is requested.
-            // http://stackoverflow.com/a/18672893/1149773
-            var tcs = new TaskCompletionSource<object>();
-            cancellationToken.Register(() => tcs.TrySetCanceled(), false);
-            var cancellationTask = tcs.Task;
-
-            // Create a task that completes when either the async operation completes,
-            // or cancellation is requested.
-            var readyTask = await Task.WhenAny(asyncTask, cancellationTask).ConfigureAwait(false);
-
-            // In case of cancellation, register a continuation to observe any unhandled
-            // exceptions from the asynchronous operation (once it completes).
-            // In .NET 4.0, unobserved task exceptions would terminate the process.
-            if (readyTask == cancellationTask)
-            {
-                // If we have a wait handle, set it so the task will terminate
-                var waitHandle = asyncResult.AsyncWaitHandle as EventWaitHandle;
-                waitHandle?.Set();
-
-                // Now register the continuation as mentioned above
-                await asyncTask.ContinueWith(_ => asyncTask.Exception,
-                    TaskContinuationOptions.OnlyOnFaulted |
-                    TaskContinuationOptions.ExecuteSynchronously).ConfigureAwait(false);
-            }
-        }
-
-        /// <summary>
-        /// Wrapper to convert a function from APM to TAP and supports cancellation tokens as seen here:
-        /// https://stackoverflow.com/questions/24980427/task-factory-fromasync-with-cancellationtokensource
-        /// </summary>
-        /// <param name="asyncResult">Async result we need to await on</param>
-        /// <param name="endMethod">End method for the async function</param>
-        /// <param name="cancellationToken">The <see cref="CancellationToken"/> to observe.</param>
-        /// <param name="factory">Optional task factory to use</param>
-        /// <param name="creationOptions">Optional task creation options to use</param>
-        /// <param name="scheduler">Optional task schedule to use</param>
+        /// <param name="cancellationCallback">Callback to call when the task is cancelled</param>
         internal static async Task<TResult> FromAsync<TResult>(
             IAsyncResult asyncResult,
             Func<IAsyncResult, TResult> endMethod,
             CancellationToken cancellationToken,
-            TaskFactory<TResult> factory,
-            TaskCreationOptions creationOptions,
-            TaskScheduler scheduler)
+            Action cancellationCallback)
         {
             // Execute the task via APM
-            factory = factory ?? Task<TResult>.Factory;
-            scheduler = scheduler ?? factory.Scheduler ?? TaskScheduler.Current;
-            var asyncTask = factory.FromAsync(asyncResult, endMethod, creationOptions, scheduler);
+            var asyncTask = Task<TResult>.Factory.FromAsync(asyncResult, endMethod);
 
             // Create another task that completes as soon as cancellation is requested.
             // http://stackoverflow.com/a/18672893/1149773
             var tcs = new TaskCompletionSource<TResult>();
-            cancellationToken.Register(() => tcs.TrySetCanceled(), false);
             var cancellationTask = tcs.Task;
-
-            // Create a task that completes when either the async operation completes,
-            // or cancellation is requested.
-            var readyTask = await Task.WhenAny(asyncTask, cancellationTask).ConfigureAwait(false);
-
-            // In case of cancellation, register a continuation to observe any unhandled
-            // exceptions from the asynchronous operation (once it completes).
-            // In .NET 4.0, unobserved task exceptions would terminate the process.
-            if (readyTask == cancellationTask)
+            using (cancellationToken.Register(() => tcs.TrySetCanceled(), false))
             {
-                // If we have a wait handle, set it so the task will terminate
-                var waitHandle = asyncResult.AsyncWaitHandle as EventWaitHandle;
-                waitHandle?.Set();
+                // Create a task that completes when either the async operation completes,
+                // or cancellation is requested.
+                var readyTask = await Task.WhenAny(asyncTask, cancellationTask).ConfigureAwait(false);
 
-                // Now register the continuation as mentioned above
-                await asyncTask.ContinueWith(_ => asyncTask.Exception,
-                    TaskContinuationOptions.OnlyOnFaulted |
-                    TaskContinuationOptions.ExecuteSynchronously).ConfigureAwait(false);
-            }
+                // Call the cancellation callback if provided to cancel the operation
+                if (readyTask == cancellationTask)
+                {
+                    cancellationCallback();
+                }
 
-            return await readyTask.ConfigureAwait(false);
+                return await readyTask.ConfigureAwait(false);
+            }
         }
     }
 }

src/Renci.SshNet/SshCommand.cs

@@ -363,52 +363,19 @@ public string Execute()
         /// Asynchronously run a command.
         /// </summary>
         /// <param name="cancellationToken">The <see cref="CancellationToken"/> to observe.</param>
-        /// <param name="factory">The <see cref="System.Threading.Tasks.TaskFactory">TaskFactory</see> used to create the Task</param>
-        /// <param name="creationOptions">The TaskCreationOptions value that controls the behavior of the
-        /// created <see cref="T:System.Threading.Tasks.Task">Task</see>.</param>
-        /// <param name="scheduler">The <see cref="System.Threading.Tasks.TaskScheduler">TaskScheduler</see>
-        /// that is used to schedule the task that executes the end method.</param>
         /// <returns>Returns <see cref="Task{Int32}"/> as command execution status result.</returns>
         public Task<int> ExecuteAsync(
-            CancellationToken cancellationToken = default(CancellationToken),
-            TaskFactory<int> factory = null,
-            TaskCreationOptions creationOptions = default(TaskCreationOptions),
-            TaskScheduler scheduler = null)
+            CancellationToken cancellationToken)
         {
             return AsyncExtensions.FromAsync(
                 BeginExecute(),
                 EndExecuteWithStatus,
                 cancellationToken,
-                factory,
-                creationOptions,
-                scheduler);
-        }
-
-        /// <summary>
-        /// Asynchronously run a command.
-        /// </summary>
-        /// <param name="commandText">The command text to execute</param>
-        /// <param name="cancellationToken">The <see cref="CancellationToken"/> to observe.</param>
-        /// <param name="factory">The <see cref="System.Threading.Tasks.TaskFactory">TaskFactory</see> used to create the Task</param>
-        /// <param name="creationOptions">The TaskCreationOptions value that controls the behavior of the
-        /// created <see cref="T:System.Threading.Tasks.Task">Task</see>.</param>
-        /// <param name="scheduler">The <see cref="System.Threading.Tasks.TaskScheduler">TaskScheduler</see>
-        /// that is used to schedule the task that executes the end method.</param>
-        /// <returns>Returns <see cref="Task{Int32}"/> as command execution status result.</returns>
-        public Task<int> ExecuteAsync(
-            string commandText,
-            CancellationToken cancellationToken = default(CancellationToken),
-            TaskFactory<int> factory = null,
-            TaskCreationOptions creationOptions = default(TaskCreationOptions),
-            TaskScheduler scheduler = null)
-        {
-            return AsyncExtensions.FromAsync(
-                BeginExecute(commandText, null, null),
-                EndExecuteWithStatus,
-                cancellationToken,
-                factory,
-                creationOptions,
-                scheduler);
+                () =>
+                {
+                    UnsubscribeFromEventsAndDisposeChannel(_channel);
+                    _channel = null;
+                });
         }
 #endif