Using a Func<Task> may be a better option

WpfViewModelFirst.Tests/MainWindowViewModelTests.cs

@@ -9,26 +9,45 @@ namespace WpfViewModelFirst.Tests
         [Fact]
         public void Part1WillSetPart1ViewModelToCurrentViewModel()
         {
-            Part1ViewModel part1ViewModel = new(() => _ = true);
+            Part1ViewModel part1ViewModel = new(() => Task.CompletedTask);
             Mock<IViewModelFactory> mockViewModelFactory = new Mock<IViewModelFactory>();
-            mockViewModelFactory.Setup(vmf => vmf.GetPart1ViewModel(It.IsAny<Action>()))
+            mockViewModelFactory.Setup(vmf => vmf.GetPart1ViewModel(It.IsAny<Func<Task>>()))
                 .Returns(part1ViewModel);
             MainWindowViewModel main = new(mockViewModelFactory.Object);
             main.Part1(null);
             Assert.Equal(part1ViewModel, main.CurrentViewModel);
         }
         [Fact]
-        public void Part1CallbackIsSuccessfull()
+        public async Task Part1CallbackIsSuccessfull()
         {
+            TaskCompletionSource<bool> taskCompletionSource = new TaskCompletionSource<bool>();
             Mock<IViewModelFactory> mockViewModelFactory = new Mock<IViewModelFactory>();
-            mockViewModelFactory.Setup(vmf => vmf.GetPart1ViewModel(It.IsAny<Action>()))
-                .Returns(() => new Part1ViewModel(() => Task.Delay(0)))
-                .Callback<Action>(c => c.Invoke());
+            mockViewModelFactory.Setup(vmf => vmf.GetPart1ViewModel(It.IsAny<Func<Task>>()))
+
+                .Returns(() => new Part1ViewModel(() =>
+                {
+                    taskCompletionSource.SetResult(true);
+                    return Task.CompletedTask;
+                }))
+                .Callback<Func<Task>>(c =>
+                {
+                    c.Invoke().ContinueWith(t =>
+                    {
+                        taskCompletionSource.SetResult(true);
+                    });
+                })
+                ;
             mockViewModelFactory.Setup(vmf => vmf.GetPart2ViewModel())
                 .Returns(() => new Part2ViewModel());
             MainWindowViewModel main = new(mockViewModelFactory.Object);
             main.Part1(null);
+            await taskCompletionSource.Task.WaitAsync(CancellationToken.None);
             Assert.IsType<Part2ViewModel>(main.CurrentViewModel);
         }
+
+        Func<Task> Part1Func()
+        {
+            return () => Task.CompletedTask;
+        }
     }
 }

WpfViewModelFirst/IViewModelFactory.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Threading.Tasks;
 using WpfViewModelFirst.Part1;
 using WpfViewModelFirst.Part2;
 
@@ -6,7 +7,7 @@ namespace WpfViewModelFirst
 {
     public interface IViewModelFactory
     {
-        Part1ViewModel GetPart1ViewModel(Action finishAction);
+        Part1ViewModel GetPart1ViewModel(Func<Task> finishAction);
         Part2ViewModel GetPart2ViewModel();
     }
 }

WpfViewModelFirst/MainWindowViewModel.cs

@@ -27,22 +27,21 @@ namespace WpfViewModelFirst
         public void Part1(object? e)
         {
             CurrentViewModel = null;
-            CurrentViewModel = _viewModelFactory.GetPart1ViewModel(Part1Action);
+            CurrentViewModel = _viewModelFactory.GetPart1ViewModel(async () => await Part1Action());
         }
-        private void Part1Action()
+        private Task Part1Action()
         {
             var currentDispatcher = Dispatcher.CurrentDispatcher;
             CurrentViewModel = null;
-            LongDelay().ContinueWith(c =>
+            return LongDelay().ContinueWith((c) =>
             {
-                System.Diagnostics.Debug.WriteLine(c.Result);
+                //System.Diagnostics.Debug.WriteLine(c.Result);
                 CurrentViewModel = _viewModelFactory.GetPart2ViewModel();
                 currentDispatcher.Invoke(() =>
                 {
                     Strings.Add($"{DateTime.Now}");
-                }
-                    );
-            }, TaskContinuationOptions.OnlyOnRanToCompletion);
+                });
+            },TaskContinuationOptions.OnlyOnRanToCompletion);
         }
 
         private async Task<string> LongDelay()

WpfViewModelFirst/Part1/Part1ViewModel.cs

@@ -9,18 +9,18 @@ namespace WpfViewModelFirst.Part1
 {
     public class Part1ViewModel : ViewModelBase
     {
-        private readonly Action _finishAction;
+        private readonly Func<Task> _finishAction;
 
-        public Part1ViewModel(Action finishAction)
+        public Part1ViewModel(Func<Task> finishAction)
         {
             _finishAction = finishAction;
-            FinishCommand = new CustomCommand(Finish);
+            FinishCommand = new CustomCommand(o => Finish(o));
         }
 
         public ICommand FinishCommand { get; set; }
-        private void Finish(object? e)
+        private Task Finish(object? e)
         {
-            _finishAction.Invoke();
+            return _finishAction.Invoke();
         }
     }
 }

WpfViewModelFirst/ViewModelFactory.cs

@@ -8,7 +8,7 @@ namespace WpfViewModelFirst
 {
     public class ViewModelFactory : IViewModelFactory
     {
-        public Part1.Part1ViewModel GetPart1ViewModel(Action finishAction)
+        public Part1.Part1ViewModel GetPart1ViewModel(Func<Task> finishAction)
         {
             return new(finishAction);
         }