From 59777a922a031ad67b5bb1a93595111d229ef86c Mon Sep 17 00:00:00 2001
From: Chris Pulman <chris.pulman@yahoo.com>
Date: Sat, 24 Jul 2021 10:29:00 +0100
Subject: [PATCH 1/3] fix IsExecuting and Can Execute threading issue

fix #2834
---
 .../CanExecuteExecutingView.xaml              | 26 +++++++++++++
 .../CanExecuteExecutingView.xaml.cs           | 26 +++++++++++++
 .../CanExecuteMock/LiveTestModeDetector.cs    | 37 ++++++++++++++++++
 .../wpf/Mocks/CommandBindingViewModel.cs      | 21 ++++++++++
 .../Platforms/wpf/WpfActiveContentTests.cs    | 38 +++++++++++++++++++
 src/ReactiveUI.Tests/ReactiveUI.Tests.csproj  |  8 ++++
 .../ReactiveCommand/ReactiveCommand.cs        |  4 +-
 7 files changed, 158 insertions(+), 2 deletions(-)
 create mode 100644 src/ReactiveUI.Tests/Platforms/wpf/Mocks/CanExecuteMock/CanExecuteExecutingView.xaml
 create mode 100644 src/ReactiveUI.Tests/Platforms/wpf/Mocks/CanExecuteMock/CanExecuteExecutingView.xaml.cs
 create mode 100644 src/ReactiveUI.Tests/Platforms/wpf/Mocks/CanExecuteMock/LiveTestModeDetector.cs

diff --git a/src/ReactiveUI.Tests/Platforms/wpf/Mocks/CanExecuteMock/CanExecuteExecutingView.xaml b/src/ReactiveUI.Tests/Platforms/wpf/Mocks/CanExecuteMock/CanExecuteExecutingView.xaml
new file mode 100644
index 0000000000..e4d20dedfc
--- /dev/null
+++ b/src/ReactiveUI.Tests/Platforms/wpf/Mocks/CanExecuteMock/CanExecuteExecutingView.xaml
@@ -0,0 +1,26 @@
+<rxui:ReactiveUserControl
+    x:Class="ReactiveUI.Tests.Wpf.CanExecuteExecutingView"
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+    xmlns:local="clr-namespace:ReactiveUI.Tests.Wpf"
+    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+    xmlns:rxui="http://reactiveui.net"
+    d:DesignHeight="450"
+    d:DesignWidth="800"
+    x:TypeArguments="local:CommandBindingViewModel"
+    mc:Ignorable="d">
+    <Grid>
+        <TextBlock Margin="0,30,0,0" Text="Test User Control" />
+        <TextBlock
+            x:Name="Result"
+            Margin="0,0,0,30"
+            VerticalAlignment="Bottom"
+            Text="Result Will be Displayed here" />
+        <Button
+            x:Name="Execute"
+            Height="30"
+            VerticalAlignment="Center"
+            Content="Execute" />
+    </Grid>
+</rxui:ReactiveUserControl>
diff --git a/src/ReactiveUI.Tests/Platforms/wpf/Mocks/CanExecuteMock/CanExecuteExecutingView.xaml.cs b/src/ReactiveUI.Tests/Platforms/wpf/Mocks/CanExecuteMock/CanExecuteExecutingView.xaml.cs
new file mode 100644
index 0000000000..2b24cfec8e
--- /dev/null
+++ b/src/ReactiveUI.Tests/Platforms/wpf/Mocks/CanExecuteMock/CanExecuteExecutingView.xaml.cs
@@ -0,0 +1,26 @@
+// Copyright (c) 2021 .NET Foundation and Contributors. All rights reserved.
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI;
+
+namespace ReactiveUI.Tests.Wpf
+{
+    /// <summary>
+    /// Interaction logic for CommandBindingView.xaml.
+    /// </summary>
+    public partial class CanExecuteExecutingView
+    {
+        public CanExecuteExecutingView()
+        {
+            InitializeComponent();
+            ViewModel = new();
+            this.WhenActivated(d =>
+            {
+                this.BindCommand(ViewModel, vm => vm.Command3, v => v.Execute);
+                this.OneWayBind(ViewModel, vm => vm.Result, v => v.Result.Text);
+            });
+        }
+    }
+}
diff --git a/src/ReactiveUI.Tests/Platforms/wpf/Mocks/CanExecuteMock/LiveTestModeDetector.cs b/src/ReactiveUI.Tests/Platforms/wpf/Mocks/CanExecuteMock/LiveTestModeDetector.cs
new file mode 100644
index 0000000000..1a6dbe8a00
--- /dev/null
+++ b/src/ReactiveUI.Tests/Platforms/wpf/Mocks/CanExecuteMock/LiveTestModeDetector.cs
@@ -0,0 +1,37 @@
+// Copyright (c) 2021 .NET Foundation and Contributors. All rights reserved.
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using ReactiveUI;
+using Splat;
+
+namespace ReactiveUI.Tests.Wpf
+{
+    /// <summary>
+    /// Live Test Mode Detector.
+    /// </summary>
+    /// <seealso cref="Splat.IModeDetector" />
+    public class LiveTestModeDetector : IModeDetector
+    {
+        private bool _useUnitTest = false;
+
+        /// <summary>
+        /// Sets the unit true.
+        /// </summary>
+        public void SetUnitTrue() => _useUnitTest = true;
+
+        /// <summary>
+        /// Sets the unit false.
+        /// </summary>
+        public void SetUnitFalse() => _useUnitTest = false;
+
+        /// <summary>
+        /// Gets a value indicating whether the current library or application is running through a unit test.
+        /// </summary>
+        /// <returns>
+        /// If we are currently running in a unit test.
+        /// </returns>
+        public bool? InUnitTestRunner() => _useUnitTest;
+    }
+}
diff --git a/src/ReactiveUI.Tests/Platforms/wpf/Mocks/CommandBindingViewModel.cs b/src/ReactiveUI.Tests/Platforms/wpf/Mocks/CommandBindingViewModel.cs
index 7de3e44125..6606a760be 100644
--- a/src/ReactiveUI.Tests/Platforms/wpf/Mocks/CommandBindingViewModel.cs
+++ b/src/ReactiveUI.Tests/Platforms/wpf/Mocks/CommandBindingViewModel.cs
@@ -3,8 +3,11 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for full license information.
 
+using System;
 using System.Reactive;
 using System.Reactive.Concurrency;
+using System.Threading;
+using System.Threading.Tasks;
 
 namespace ReactiveUI.Tests.Wpf
 {
@@ -12,6 +15,8 @@ public class CommandBindingViewModel : ReactiveObject
     {
         private ReactiveCommand<int, int> _Command1;
         private ReactiveCommand<Unit, Unit> _Command2;
+        private ReactiveCommand<Unit, int?> _Command3;
+        private ObservableAsPropertyHelper<int?> _result;
 
         private int _value;
 
@@ -19,6 +24,8 @@ public CommandBindingViewModel()
         {
             _Command1 = ReactiveCommand.Create<int, int>(_ => { return _; }, outputScheduler: ImmediateScheduler.Instance);
             _Command2 = ReactiveCommand.Create(() => { }, outputScheduler: ImmediateScheduler.Instance);
+            _Command3 = ReactiveCommand.CreateFromTask(RunAsync, outputScheduler: TaskPoolScheduler.Default);
+            _result = _Command3.ToProperty(this, x => x.Result, scheduler: RxApp.MainThreadScheduler);
         }
 
         public ReactiveCommand<int, int> Command1
@@ -33,6 +40,12 @@ public CommandBindingViewModel()
             set => this.RaiseAndSetIfChanged(ref _Command2, value);
         }
 
+        public ReactiveCommand<Unit, int?> Command3
+        {
+            get => _Command3;
+            set => this.RaiseAndSetIfChanged(ref _Command3, value);
+        }
+
         public FakeNestedViewModel? NestedViewModel { get; set; }
 
         public int Value
@@ -40,5 +53,13 @@ public int Value
             get => _value;
             set => this.RaiseAndSetIfChanged(ref _value, value);
         }
+
+        public int? Result => _result.Value;
+
+        private async Task<int?> RunAsync(CancellationToken cancellationToken)
+        {
+            await Task.Delay(1000, cancellationToken).ConfigureAwait(false);
+            return cancellationToken.IsCancellationRequested ? null : 100;
+        }
     }
 }
diff --git a/src/ReactiveUI.Tests/Platforms/wpf/WpfActiveContentTests.cs b/src/ReactiveUI.Tests/Platforms/wpf/WpfActiveContentTests.cs
index 2e418fd295..00610e3395 100644
--- a/src/ReactiveUI.Tests/Platforms/wpf/WpfActiveContentTests.cs
+++ b/src/ReactiveUI.Tests/Platforms/wpf/WpfActiveContentTests.cs
@@ -8,6 +8,7 @@
 using System.Threading.Tasks;
 using System.Windows;
 using DynamicData;
+using Splat;
 using Xunit;
 
 namespace ReactiveUI.Tests.Wpf
@@ -20,6 +21,7 @@ namespace ReactiveUI.Tests.Wpf
     public class WpfActiveContentTests : IClassFixture<WpfActiveContentFixture>
     {
 #pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
+        private static bool isExecutingExecuted = false;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="WpfActiveContentTests"/> class.
@@ -198,6 +200,42 @@ public void TransitioninContentControlDpiTest()
             window!.ShowDialog();
         }
 
+        [StaFact]
+        public void ReactiveCommandRunningOnTaskThreadAllowsCanExecuteAndExecutingToFire()
+        {
+            var modeDetector = new LiveTestModeDetector();
+            ModeDetector.OverrideModeDetector(modeDetector);
+            var window = Fixture?.App?.MockWindowFactory();
+            window!.WhenActivated(async d =>
+            {
+                var view = new CanExecuteExecutingView();
+                view!.ViewModel = new();
+                isExecutingExecuted = false;
+                window!.TransitioningContent.VerticalContentAlignment = VerticalAlignment.Stretch;
+                window!.TransitioningContent.HorizontalContentAlignment = HorizontalAlignment.Stretch;
+                window!.TransitioningContent.Content = view;
+                await Task.Delay(5000).ConfigureAwait(true);
+                int? result = null;
+                view!.ViewModel!.Command3.IsExecuting
+                .Subscribe(static value =>
+                {
+                    if (value)
+                    {
+                        isExecutingExecuted = true;
+                    }
+                });
+                view!.ViewModel!.Command3.Subscribe(r => result = r);
+                await view!.ViewModel!.Command3.Execute();
+                await Task.Delay(5000).ConfigureAwait(true);
+                Assert.True(isExecutingExecuted);
+
+                Assert.Equal(100, result);
+
+                window.Close();
+            });
+            window!.ShowDialog();
+        }
+
 #pragma warning restore CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
     }
 }
diff --git a/src/ReactiveUI.Tests/ReactiveUI.Tests.csproj b/src/ReactiveUI.Tests/ReactiveUI.Tests.csproj
index b54cfb40a5..100f653c92 100644
--- a/src/ReactiveUI.Tests/ReactiveUI.Tests.csproj
+++ b/src/ReactiveUI.Tests/ReactiveUI.Tests.csproj
@@ -74,6 +74,8 @@
   </Choose>
 
   <ItemGroup>
+    <None Remove="Platforms\wpf\Mocks\CanExecuteMock\CanExecuteExecutingView.xaml.cs" />
+    <None Remove="Platforms\wpf\Mocks\CanExecuteMock\LiveTestModeDetector.cs" />
     <None Remove="Platforms\wpf\WpfGeneralFixture.cs" />
     <None Remove="Platforms\wpf\WpfGeneralFixtureApp.cs" />
   </ItemGroup>
@@ -93,5 +95,11 @@
       <DependentUpon>TestFormNotCanActivate.resx</DependentUpon>
     </Compile>
   </ItemGroup>
+
+  <ItemGroup>
+    <Page Update="Platforms\wpf\Mocks\CanExecuteMock\CanExecuteExecutingView.xaml">
+      <XamlRuntime>$(DefaultXamlRuntime)</XamlRuntime>
+    </Page>
+  </ItemGroup>
   
 </Project>
diff --git a/src/ReactiveUI/ReactiveCommand/ReactiveCommand.cs b/src/ReactiveUI/ReactiveCommand/ReactiveCommand.cs
index 930961ac6a..332a6831c2 100644
--- a/src/ReactiveUI/ReactiveCommand/ReactiveCommand.cs
+++ b/src/ReactiveUI/ReactiveCommand/ReactiveCommand.cs
@@ -679,7 +679,7 @@ public class ReactiveCommand<TParam, TResult> : ReactiveCommandBase<TParam, TRes
                      };
                  }).Select(inFlightCount => inFlightCount > 0).StartWith(false)
                  .DistinctUntilChanged().Replay(1)
-                 .RefCount();
+                 .RefCount().ObserveOn(RxApp.MainThreadScheduler);
 
             _canExecute = canExecute.Catch<bool, Exception>(
                 ex =>
@@ -688,7 +688,7 @@ public class ReactiveCommand<TParam, TResult> : ReactiveCommandBase<TParam, TRes
                     return Observables.False;
                 }).StartWith(false).CombineLatest(_isExecuting, (canEx, isEx) => canEx && !isEx)
                 .DistinctUntilChanged()
-                .Replay(1).RefCount();
+                .Replay(1).RefCount().ObserveOn(RxApp.MainThreadScheduler);
             _results = _synchronizedExecutionInfo.Where(x => x.Demarcation == ExecutionDemarcation.Result)
                 .Select(x => x.Result);
 

From 2f8ca671dc45cf1864b0f888f9e48da88e55274b Mon Sep 17 00:00:00 2001
From: Chris Pulman <chris.pulman@yahoo.com>
Date: Sat, 24 Jul 2021 19:16:17 +0100
Subject: [PATCH 2/3] Tidied up

Changed location of ObserveOn as found route cause of the fault.
---
 ...Detector.cs => AlwaysFalseModeDetector.cs} | 18 +-----
 .../CanExecuteExecutingView.xaml.cs           |  2 -
 .../Mocks/CanExecuteMock/LiveModeDetector.cs  | 23 ++++++++
 .../wpf/Mocks/CommandBindingViewModel.cs      |  2 +-
 .../Platforms/wpf/WpfActiveContentTests.cs    | 56 ++++++++++---------
 src/ReactiveUI.Tests/ReactiveUI.Tests.csproj  |  3 +-
 .../ReactiveCommand/ReactiveCommand.cs        |  8 +--
 7 files changed, 64 insertions(+), 48 deletions(-)
 rename src/ReactiveUI.Tests/Platforms/wpf/Mocks/CanExecuteMock/{LiveTestModeDetector.cs => AlwaysFalseModeDetector.cs} (60%)
 create mode 100644 src/ReactiveUI.Tests/Platforms/wpf/Mocks/CanExecuteMock/LiveModeDetector.cs

diff --git a/src/ReactiveUI.Tests/Platforms/wpf/Mocks/CanExecuteMock/LiveTestModeDetector.cs b/src/ReactiveUI.Tests/Platforms/wpf/Mocks/CanExecuteMock/AlwaysFalseModeDetector.cs
similarity index 60%
rename from src/ReactiveUI.Tests/Platforms/wpf/Mocks/CanExecuteMock/LiveTestModeDetector.cs
rename to src/ReactiveUI.Tests/Platforms/wpf/Mocks/CanExecuteMock/AlwaysFalseModeDetector.cs
index 1a6dbe8a00..140ed16ea0 100644
--- a/src/ReactiveUI.Tests/Platforms/wpf/Mocks/CanExecuteMock/LiveTestModeDetector.cs
+++ b/src/ReactiveUI.Tests/Platforms/wpf/Mocks/CanExecuteMock/AlwaysFalseModeDetector.cs
@@ -9,29 +9,17 @@
 namespace ReactiveUI.Tests.Wpf
 {
     /// <summary>
-    /// Live Test Mode Detector.
+    /// Always False Mode Detector.
     /// </summary>
     /// <seealso cref="Splat.IModeDetector" />
-    public class LiveTestModeDetector : IModeDetector
+    public class AlwaysFalseModeDetector : IModeDetector
     {
-        private bool _useUnitTest = false;
-
-        /// <summary>
-        /// Sets the unit true.
-        /// </summary>
-        public void SetUnitTrue() => _useUnitTest = true;
-
-        /// <summary>
-        /// Sets the unit false.
-        /// </summary>
-        public void SetUnitFalse() => _useUnitTest = false;
-
         /// <summary>
         /// Gets a value indicating whether the current library or application is running through a unit test.
         /// </summary>
         /// <returns>
         /// If we are currently running in a unit test.
         /// </returns>
-        public bool? InUnitTestRunner() => _useUnitTest;
+        public bool? InUnitTestRunner() => false;
     }
 }
diff --git a/src/ReactiveUI.Tests/Platforms/wpf/Mocks/CanExecuteMock/CanExecuteExecutingView.xaml.cs b/src/ReactiveUI.Tests/Platforms/wpf/Mocks/CanExecuteMock/CanExecuteExecutingView.xaml.cs
index 2b24cfec8e..5598e61f47 100644
--- a/src/ReactiveUI.Tests/Platforms/wpf/Mocks/CanExecuteMock/CanExecuteExecutingView.xaml.cs
+++ b/src/ReactiveUI.Tests/Platforms/wpf/Mocks/CanExecuteMock/CanExecuteExecutingView.xaml.cs
@@ -3,8 +3,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for full license information.
 
-using ReactiveUI;
-
 namespace ReactiveUI.Tests.Wpf
 {
     /// <summary>
diff --git a/src/ReactiveUI.Tests/Platforms/wpf/Mocks/CanExecuteMock/LiveModeDetector.cs b/src/ReactiveUI.Tests/Platforms/wpf/Mocks/CanExecuteMock/LiveModeDetector.cs
new file mode 100644
index 0000000000..5becc9a580
--- /dev/null
+++ b/src/ReactiveUI.Tests/Platforms/wpf/Mocks/CanExecuteMock/LiveModeDetector.cs
@@ -0,0 +1,23 @@
+// Copyright (c) 2021 .NET Foundation and Contributors. All rights reserved.
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using Splat;
+
+namespace ReactiveUI.Tests.Wpf
+{
+    public static class LiveModeDetector
+    {
+        private static AlwaysFalseModeDetector liveModeDetector = new();
+        private static DefaultModeDetector defaultModeDetector = new();
+
+        public static void UseRuntimeThreads() =>
+            ModeDetector.OverrideModeDetector(liveModeDetector);
+
+        public static void UseDefaultModeDetector() =>
+            ModeDetector.OverrideModeDetector(defaultModeDetector);
+
+        public static bool? InUnitTestRunner() => ModeDetector.InUnitTestRunner();
+    }
+}
diff --git a/src/ReactiveUI.Tests/Platforms/wpf/Mocks/CommandBindingViewModel.cs b/src/ReactiveUI.Tests/Platforms/wpf/Mocks/CommandBindingViewModel.cs
index 6606a760be..74e0ce729a 100644
--- a/src/ReactiveUI.Tests/Platforms/wpf/Mocks/CommandBindingViewModel.cs
+++ b/src/ReactiveUI.Tests/Platforms/wpf/Mocks/CommandBindingViewModel.cs
@@ -24,7 +24,7 @@ public CommandBindingViewModel()
         {
             _Command1 = ReactiveCommand.Create<int, int>(_ => { return _; }, outputScheduler: ImmediateScheduler.Instance);
             _Command2 = ReactiveCommand.Create(() => { }, outputScheduler: ImmediateScheduler.Instance);
-            _Command3 = ReactiveCommand.CreateFromTask(RunAsync, outputScheduler: TaskPoolScheduler.Default);
+            _Command3 = ReactiveCommand.CreateFromTask(RunAsync, outputScheduler: RxApp.TaskpoolScheduler);
             _result = _Command3.ToProperty(this, x => x.Result, scheduler: RxApp.MainThreadScheduler);
         }
 
diff --git a/src/ReactiveUI.Tests/Platforms/wpf/WpfActiveContentTests.cs b/src/ReactiveUI.Tests/Platforms/wpf/WpfActiveContentTests.cs
index 00610e3395..bd6d8e778d 100644
--- a/src/ReactiveUI.Tests/Platforms/wpf/WpfActiveContentTests.cs
+++ b/src/ReactiveUI.Tests/Platforms/wpf/WpfActiveContentTests.cs
@@ -4,6 +4,7 @@
 // See the LICENSE file in the project root for full license information.
 
 using System;
+using System.Reactive.Disposables;
 using System.Reactive.Linq;
 using System.Threading.Tasks;
 using System.Windows;
@@ -21,7 +22,6 @@ namespace ReactiveUI.Tests.Wpf
     public class WpfActiveContentTests : IClassFixture<WpfActiveContentFixture>
     {
 #pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
-        private static bool isExecutingExecuted = false;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="WpfActiveContentTests"/> class.
@@ -203,35 +203,41 @@ public void TransitioninContentControlDpiTest()
         [StaFact]
         public void ReactiveCommandRunningOnTaskThreadAllowsCanExecuteAndExecutingToFire()
         {
-            var modeDetector = new LiveTestModeDetector();
-            ModeDetector.OverrideModeDetector(modeDetector);
+            LiveModeDetector.UseRuntimeThreads();
             var window = Fixture?.App?.MockWindowFactory();
             window!.WhenActivated(async d =>
             {
-                var view = new CanExecuteExecutingView();
-                view!.ViewModel = new();
-                isExecutingExecuted = false;
-                window!.TransitioningContent.VerticalContentAlignment = VerticalAlignment.Stretch;
-                window!.TransitioningContent.HorizontalContentAlignment = HorizontalAlignment.Stretch;
-                window!.TransitioningContent.Content = view;
-                await Task.Delay(5000).ConfigureAwait(true);
-                int? result = null;
-                view!.ViewModel!.Command3.IsExecuting
-                .Subscribe(static value =>
+                try
                 {
-                    if (value)
+                    window!.TransitioningContent.VerticalContentAlignment = VerticalAlignment.Stretch;
+                    window!.TransitioningContent.HorizontalContentAlignment = HorizontalAlignment.Stretch;
+                    var view = new CanExecuteExecutingView();
+                    window!.TransitioningContent.Content = view;
+                    await Task.Delay(5000).ConfigureAwait(true);
+
+                    var isExecutingExecuted = false;
+                    view!.ViewModel!.Command3.IsExecuting
+                    .ObserveOn(RxApp.MainThreadScheduler)
+                    .Subscribe(value =>
                     {
-                        isExecutingExecuted = true;
-                    }
-                });
-                view!.ViewModel!.Command3.Subscribe(r => result = r);
-                await view!.ViewModel!.Command3.Execute();
-                await Task.Delay(5000).ConfigureAwait(true);
-                Assert.True(isExecutingExecuted);
-
-                Assert.Equal(100, result);
-
-                window.Close();
+                        if (value)
+                        {
+                            isExecutingExecuted = true;
+                        }
+                    }).DisposeWith(d);
+
+                    int? result = null;
+                    view!.ViewModel!.Command3.Subscribe(r => result = r);
+                    await view!.ViewModel!.Command3.Execute();
+                    await Task.Delay(5000).ConfigureAwait(true);
+                    Assert.Equal(100, result);
+                    Assert.True(isExecutingExecuted);
+                }
+                finally
+                {
+                    window?.Close();
+                    LiveModeDetector.UseDefaultModeDetector();
+                }
             });
             window!.ShowDialog();
         }
diff --git a/src/ReactiveUI.Tests/ReactiveUI.Tests.csproj b/src/ReactiveUI.Tests/ReactiveUI.Tests.csproj
index 100f653c92..05c909d873 100644
--- a/src/ReactiveUI.Tests/ReactiveUI.Tests.csproj
+++ b/src/ReactiveUI.Tests/ReactiveUI.Tests.csproj
@@ -74,8 +74,9 @@
   </Choose>
 
   <ItemGroup>
+    <None Remove="Platforms\wpf\Mocks\CanExecuteMock\AlwaysFalseModeDetector.cs" />
     <None Remove="Platforms\wpf\Mocks\CanExecuteMock\CanExecuteExecutingView.xaml.cs" />
-    <None Remove="Platforms\wpf\Mocks\CanExecuteMock\LiveTestModeDetector.cs" />
+    <None Remove="Platforms\wpf\Mocks\CanExecuteMock\LiveModeDetector.cs" />
     <None Remove="Platforms\wpf\WpfGeneralFixture.cs" />
     <None Remove="Platforms\wpf\WpfGeneralFixtureApp.cs" />
   </ItemGroup>
diff --git a/src/ReactiveUI/ReactiveCommand/ReactiveCommand.cs b/src/ReactiveUI/ReactiveCommand/ReactiveCommand.cs
index 332a6831c2..468db3b9cb 100644
--- a/src/ReactiveUI/ReactiveCommand/ReactiveCommand.cs
+++ b/src/ReactiveUI/ReactiveCommand/ReactiveCommand.cs
@@ -664,7 +664,6 @@ public class ReactiveCommand<TParam, TResult> : ReactiveCommandBase<TParam, TRes
             _execute = execute ?? throw new ArgumentNullException(nameof(execute));
             _outputScheduler = outputScheduler ?? throw new ArgumentNullException(nameof(outputScheduler));
             _exceptions = new ScheduledSubject<Exception>(outputScheduler, RxApp.DefaultExceptionHandler);
-
             _executionInfo = new Subject<ExecutionInfo>();
             _synchronizedExecutionInfo = Subject.Synchronize(_executionInfo, outputScheduler);
             _isExecuting = _synchronizedExecutionInfo.Scan(
@@ -679,7 +678,7 @@ public class ReactiveCommand<TParam, TResult> : ReactiveCommandBase<TParam, TRes
                      };
                  }).Select(inFlightCount => inFlightCount > 0).StartWith(false)
                  .DistinctUntilChanged().Replay(1)
-                 .RefCount().ObserveOn(RxApp.MainThreadScheduler);
+                 .RefCount();
 
             _canExecute = canExecute.Catch<bool, Exception>(
                 ex =>
@@ -688,11 +687,12 @@ public class ReactiveCommand<TParam, TResult> : ReactiveCommandBase<TParam, TRes
                     return Observables.False;
                 }).StartWith(false).CombineLatest(_isExecuting, (canEx, isEx) => canEx && !isEx)
                 .DistinctUntilChanged()
-                .Replay(1).RefCount().ObserveOn(RxApp.MainThreadScheduler);
+                .Replay(1).RefCount();
+
             _results = _synchronizedExecutionInfo.Where(x => x.Demarcation == ExecutionDemarcation.Result)
                 .Select(x => x.Result);
 
-            _canExecuteSubscription = _canExecute.Subscribe(OnCanExecuteChanged);
+            _canExecuteSubscription = _canExecute.ObserveOn(RxApp.MainThreadScheduler).Subscribe(OnCanExecuteChanged);
         }
 
         private enum ExecutionDemarcation

From b8496926b519682c0685a18c01d59ed2008796d0 Mon Sep 17 00:00:00 2001
From: Chris Pulman <chris.pulman@yahoo.com>
Date: Sat, 24 Jul 2021 23:23:25 +0100
Subject: [PATCH 3/3] added canExecuteScheduler to reactiveCommand and
 CombinedReactiveComand

users should recheck their code to ensure correct operation and set the canExecuteScheduler as required.
---
 ...provalTests.ReactiveUI.net472.approved.txt |  34 ++--
 ...provalTests.ReactiveUI.net5.0.approved.txt |  34 ++--
 ...ests.ReactiveUI.netcoreapp3.1.approved.txt |  34 ++--
 .../Commands/ReactiveCommandTest.cs           |   2 +-
 .../CombinedReactiveCommand.cs                |  17 +-
 .../ReactiveCommand/ReactiveCommand.cs        | 158 +++++++++++++-----
 .../ReactiveCommand/ReactiveCommandBase.cs    |   2 +-
 7 files changed, 187 insertions(+), 94 deletions(-)

diff --git a/src/ReactiveUI.Tests/API/ApiApprovalTests.ReactiveUI.net472.approved.txt b/src/ReactiveUI.Tests/API/ApiApprovalTests.ReactiveUI.net472.approved.txt
index 64d3ecc199..16a1bb8b57 100644
--- a/src/ReactiveUI.Tests/API/ApiApprovalTests.ReactiveUI.net472.approved.txt
+++ b/src/ReactiveUI.Tests/API/ApiApprovalTests.ReactiveUI.net472.approved.txt
@@ -57,7 +57,7 @@ namespace ReactiveUI
     }
     public class CombinedReactiveCommand<TParam, TResult> : ReactiveUI.ReactiveCommandBase<TParam, System.Collections.Generic.IList<TResult>>
     {
-        protected CombinedReactiveCommand(System.Collections.Generic.IEnumerable<ReactiveUI.ReactiveCommandBase<TParam, TResult>> childCommands, System.IObservable<bool> canExecute, System.Reactive.Concurrency.IScheduler outputScheduler) { }
+        protected CombinedReactiveCommand(System.Collections.Generic.IEnumerable<ReactiveUI.ReactiveCommandBase<TParam, TResult>> childCommands, System.IObservable<bool> canExecute, System.Reactive.Concurrency.IScheduler outputScheduler, System.Reactive.Concurrency.IScheduler canExecuteScheduler) { }
         public override System.IObservable<bool> CanExecute { get; }
         public override System.IObservable<bool> IsExecuting { get; }
         public override System.IObservable<System.Exception> ThrownExceptions { get; }
@@ -555,21 +555,21 @@ namespace ReactiveUI
     }
     public static class ReactiveCommand
     {
-        public static ReactiveUI.ReactiveCommand<System.Reactive.Unit, System.Reactive.Unit> Create(System.Action execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null) { }
-        public static ReactiveUI.ReactiveCommand<TParam, System.Reactive.Unit> Create<TParam>(System.Action<TParam> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null) { }
-        public static ReactiveUI.ReactiveCommand<System.Reactive.Unit, TResult> Create<TResult>(System.Func<TResult> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null) { }
-        public static ReactiveUI.ReactiveCommand<TParam, TResult> Create<TParam, TResult>(System.Func<TParam, TResult> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null) { }
-        public static ReactiveUI.CombinedReactiveCommand<TParam, TResult> CreateCombined<TParam, TResult>(System.Collections.Generic.IEnumerable<ReactiveUI.ReactiveCommandBase<TParam, TResult>> childCommands, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null) { }
-        public static ReactiveUI.ReactiveCommand<System.Reactive.Unit, TResult> CreateFromObservable<TResult>(System.Func<System.IObservable<TResult>> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null) { }
-        public static ReactiveUI.ReactiveCommand<TParam, TResult> CreateFromObservable<TParam, TResult>(System.Func<TParam, System.IObservable<TResult>> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null) { }
-        public static ReactiveUI.ReactiveCommand<System.Reactive.Unit, System.Reactive.Unit> CreateFromTask(System.Func<System.Threading.Tasks.Task> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null) { }
-        public static ReactiveUI.ReactiveCommand<System.Reactive.Unit, System.Reactive.Unit> CreateFromTask(System.Func<System.Threading.CancellationToken, System.Threading.Tasks.Task> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null) { }
-        public static ReactiveUI.ReactiveCommand<System.Reactive.Unit, TResult> CreateFromTask<TResult>(System.Func<System.Threading.Tasks.Task<TResult>> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null) { }
-        public static ReactiveUI.ReactiveCommand<System.Reactive.Unit, TResult> CreateFromTask<TResult>(System.Func<System.Threading.CancellationToken, System.Threading.Tasks.Task<TResult>> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null) { }
-        public static ReactiveUI.ReactiveCommand<TParam, System.Reactive.Unit> CreateFromTask<TParam>(System.Func<TParam, System.Threading.Tasks.Task> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null) { }
-        public static ReactiveUI.ReactiveCommand<TParam, System.Reactive.Unit> CreateFromTask<TParam>(System.Func<TParam, System.Threading.CancellationToken, System.Threading.Tasks.Task> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null) { }
-        public static ReactiveUI.ReactiveCommand<TParam, TResult> CreateFromTask<TParam, TResult>(System.Func<TParam, System.Threading.Tasks.Task<TResult>> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null) { }
-        public static ReactiveUI.ReactiveCommand<TParam, TResult> CreateFromTask<TParam, TResult>(System.Func<TParam, System.Threading.CancellationToken, System.Threading.Tasks.Task<TResult>> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null) { }
+        public static ReactiveUI.ReactiveCommand<System.Reactive.Unit, System.Reactive.Unit> Create(System.Action execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null, System.Reactive.Concurrency.IScheduler? canExecuteScheduler = null) { }
+        public static ReactiveUI.ReactiveCommand<TParam, System.Reactive.Unit> Create<TParam>(System.Action<TParam> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null, System.Reactive.Concurrency.IScheduler? canExecuteScheduler = null) { }
+        public static ReactiveUI.ReactiveCommand<System.Reactive.Unit, TResult> Create<TResult>(System.Func<TResult> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null, System.Reactive.Concurrency.IScheduler? canExecuteScheduler = null) { }
+        public static ReactiveUI.ReactiveCommand<TParam, TResult> Create<TParam, TResult>(System.Func<TParam, TResult> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null, System.Reactive.Concurrency.IScheduler? canExecuteScheduler = null) { }
+        public static ReactiveUI.CombinedReactiveCommand<TParam, TResult> CreateCombined<TParam, TResult>(System.Collections.Generic.IEnumerable<ReactiveUI.ReactiveCommandBase<TParam, TResult>> childCommands, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null, System.Reactive.Concurrency.IScheduler? canExecuteScheduler = null) { }
+        public static ReactiveUI.ReactiveCommand<System.Reactive.Unit, TResult> CreateFromObservable<TResult>(System.Func<System.IObservable<TResult>> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null, System.Reactive.Concurrency.IScheduler? canExecuteScheduler = null) { }
+        public static ReactiveUI.ReactiveCommand<TParam, TResult> CreateFromObservable<TParam, TResult>(System.Func<TParam, System.IObservable<TResult>> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null, System.Reactive.Concurrency.IScheduler? canExecuteScheduler = null) { }
+        public static ReactiveUI.ReactiveCommand<System.Reactive.Unit, System.Reactive.Unit> CreateFromTask(System.Func<System.Threading.Tasks.Task> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null, System.Reactive.Concurrency.IScheduler? canExecuteScheduler = null) { }
+        public static ReactiveUI.ReactiveCommand<System.Reactive.Unit, System.Reactive.Unit> CreateFromTask(System.Func<System.Threading.CancellationToken, System.Threading.Tasks.Task> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null, System.Reactive.Concurrency.IScheduler? canExecuteScheduler = null) { }
+        public static ReactiveUI.ReactiveCommand<System.Reactive.Unit, TResult> CreateFromTask<TResult>(System.Func<System.Threading.Tasks.Task<TResult>> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null, System.Reactive.Concurrency.IScheduler? canExecuteScheduler = null) { }
+        public static ReactiveUI.ReactiveCommand<System.Reactive.Unit, TResult> CreateFromTask<TResult>(System.Func<System.Threading.CancellationToken, System.Threading.Tasks.Task<TResult>> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null, System.Reactive.Concurrency.IScheduler? canExecuteScheduler = null) { }
+        public static ReactiveUI.ReactiveCommand<TParam, System.Reactive.Unit> CreateFromTask<TParam>(System.Func<TParam, System.Threading.Tasks.Task> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null, System.Reactive.Concurrency.IScheduler? canExecuteScheduler = null) { }
+        public static ReactiveUI.ReactiveCommand<TParam, System.Reactive.Unit> CreateFromTask<TParam>(System.Func<TParam, System.Threading.CancellationToken, System.Threading.Tasks.Task> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null, System.Reactive.Concurrency.IScheduler? canExecuteScheduler = null) { }
+        public static ReactiveUI.ReactiveCommand<TParam, TResult> CreateFromTask<TParam, TResult>(System.Func<TParam, System.Threading.Tasks.Task<TResult>> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null, System.Reactive.Concurrency.IScheduler? canExecuteScheduler = null) { }
+        public static ReactiveUI.ReactiveCommand<TParam, TResult> CreateFromTask<TParam, TResult>(System.Func<TParam, System.Threading.CancellationToken, System.Threading.Tasks.Task<TResult>> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null, System.Reactive.Concurrency.IScheduler? canExecuteScheduler = null) { }
     }
     public abstract class ReactiveCommandBase<TParam, TResult> : ReactiveUI.IHandleObservableErrors, ReactiveUI.IReactiveCommand, System.IDisposable, System.IObservable<TResult>, System.Windows.Input.ICommand
     {
@@ -597,7 +597,7 @@ namespace ReactiveUI
     }
     public class ReactiveCommand<TParam, TResult> : ReactiveUI.ReactiveCommandBase<TParam, TResult>
     {
-        protected ReactiveCommand(System.Func<TParam, System.IObservable<TResult>> execute, System.IObservable<bool>? canExecute, System.Reactive.Concurrency.IScheduler? outputScheduler) { }
+        protected ReactiveCommand(System.Func<TParam, System.IObservable<TResult>> execute, System.IObservable<bool>? canExecute, System.Reactive.Concurrency.IScheduler? outputScheduler, System.Reactive.Concurrency.IScheduler? canExecuteScheduler) { }
         public override System.IObservable<bool> CanExecute { get; }
         public override System.IObservable<bool> IsExecuting { get; }
         public override System.IObservable<System.Exception> ThrownExceptions { get; }
diff --git a/src/ReactiveUI.Tests/API/ApiApprovalTests.ReactiveUI.net5.0.approved.txt b/src/ReactiveUI.Tests/API/ApiApprovalTests.ReactiveUI.net5.0.approved.txt
index 256721d4fe..1ca8c61df7 100644
--- a/src/ReactiveUI.Tests/API/ApiApprovalTests.ReactiveUI.net5.0.approved.txt
+++ b/src/ReactiveUI.Tests/API/ApiApprovalTests.ReactiveUI.net5.0.approved.txt
@@ -59,7 +59,7 @@ namespace ReactiveUI
     }
     public class CombinedReactiveCommand<TParam, TResult> : ReactiveUI.ReactiveCommandBase<TParam, System.Collections.Generic.IList<TResult>>
     {
-        protected CombinedReactiveCommand(System.Collections.Generic.IEnumerable<ReactiveUI.ReactiveCommandBase<TParam, TResult>> childCommands, System.IObservable<bool> canExecute, System.Reactive.Concurrency.IScheduler outputScheduler) { }
+        protected CombinedReactiveCommand(System.Collections.Generic.IEnumerable<ReactiveUI.ReactiveCommandBase<TParam, TResult>> childCommands, System.IObservable<bool> canExecute, System.Reactive.Concurrency.IScheduler outputScheduler, System.Reactive.Concurrency.IScheduler canExecuteScheduler) { }
         public override System.IObservable<bool> CanExecute { get; }
         public override System.IObservable<bool> IsExecuting { get; }
         public override System.IObservable<System.Exception> ThrownExceptions { get; }
@@ -550,21 +550,21 @@ namespace ReactiveUI
     }
     public static class ReactiveCommand
     {
-        public static ReactiveUI.ReactiveCommand<System.Reactive.Unit, System.Reactive.Unit> Create(System.Action execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null) { }
-        public static ReactiveUI.ReactiveCommand<TParam, System.Reactive.Unit> Create<TParam>(System.Action<TParam> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null) { }
-        public static ReactiveUI.ReactiveCommand<System.Reactive.Unit, TResult> Create<TResult>(System.Func<TResult> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null) { }
-        public static ReactiveUI.ReactiveCommand<TParam, TResult> Create<TParam, TResult>(System.Func<TParam, TResult> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null) { }
-        public static ReactiveUI.CombinedReactiveCommand<TParam, TResult> CreateCombined<TParam, TResult>(System.Collections.Generic.IEnumerable<ReactiveUI.ReactiveCommandBase<TParam, TResult>> childCommands, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null) { }
-        public static ReactiveUI.ReactiveCommand<System.Reactive.Unit, TResult> CreateFromObservable<TResult>(System.Func<System.IObservable<TResult>> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null) { }
-        public static ReactiveUI.ReactiveCommand<TParam, TResult> CreateFromObservable<TParam, TResult>(System.Func<TParam, System.IObservable<TResult>> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null) { }
-        public static ReactiveUI.ReactiveCommand<System.Reactive.Unit, System.Reactive.Unit> CreateFromTask(System.Func<System.Threading.Tasks.Task> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null) { }
-        public static ReactiveUI.ReactiveCommand<System.Reactive.Unit, System.Reactive.Unit> CreateFromTask(System.Func<System.Threading.CancellationToken, System.Threading.Tasks.Task> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null) { }
-        public static ReactiveUI.ReactiveCommand<System.Reactive.Unit, TResult> CreateFromTask<TResult>(System.Func<System.Threading.Tasks.Task<TResult>> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null) { }
-        public static ReactiveUI.ReactiveCommand<System.Reactive.Unit, TResult> CreateFromTask<TResult>(System.Func<System.Threading.CancellationToken, System.Threading.Tasks.Task<TResult>> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null) { }
-        public static ReactiveUI.ReactiveCommand<TParam, System.Reactive.Unit> CreateFromTask<TParam>(System.Func<TParam, System.Threading.Tasks.Task> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null) { }
-        public static ReactiveUI.ReactiveCommand<TParam, System.Reactive.Unit> CreateFromTask<TParam>(System.Func<TParam, System.Threading.CancellationToken, System.Threading.Tasks.Task> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null) { }
-        public static ReactiveUI.ReactiveCommand<TParam, TResult> CreateFromTask<TParam, TResult>(System.Func<TParam, System.Threading.Tasks.Task<TResult>> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null) { }
-        public static ReactiveUI.ReactiveCommand<TParam, TResult> CreateFromTask<TParam, TResult>(System.Func<TParam, System.Threading.CancellationToken, System.Threading.Tasks.Task<TResult>> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null) { }
+        public static ReactiveUI.ReactiveCommand<System.Reactive.Unit, System.Reactive.Unit> Create(System.Action execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null, System.Reactive.Concurrency.IScheduler? canExecuteScheduler = null) { }
+        public static ReactiveUI.ReactiveCommand<TParam, System.Reactive.Unit> Create<TParam>(System.Action<TParam> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null, System.Reactive.Concurrency.IScheduler? canExecuteScheduler = null) { }
+        public static ReactiveUI.ReactiveCommand<System.Reactive.Unit, TResult> Create<TResult>(System.Func<TResult> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null, System.Reactive.Concurrency.IScheduler? canExecuteScheduler = null) { }
+        public static ReactiveUI.ReactiveCommand<TParam, TResult> Create<TParam, TResult>(System.Func<TParam, TResult> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null, System.Reactive.Concurrency.IScheduler? canExecuteScheduler = null) { }
+        public static ReactiveUI.CombinedReactiveCommand<TParam, TResult> CreateCombined<TParam, TResult>(System.Collections.Generic.IEnumerable<ReactiveUI.ReactiveCommandBase<TParam, TResult>> childCommands, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null, System.Reactive.Concurrency.IScheduler? canExecuteScheduler = null) { }
+        public static ReactiveUI.ReactiveCommand<System.Reactive.Unit, TResult> CreateFromObservable<TResult>(System.Func<System.IObservable<TResult>> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null, System.Reactive.Concurrency.IScheduler? canExecuteScheduler = null) { }
+        public static ReactiveUI.ReactiveCommand<TParam, TResult> CreateFromObservable<TParam, TResult>(System.Func<TParam, System.IObservable<TResult>> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null, System.Reactive.Concurrency.IScheduler? canExecuteScheduler = null) { }
+        public static ReactiveUI.ReactiveCommand<System.Reactive.Unit, System.Reactive.Unit> CreateFromTask(System.Func<System.Threading.Tasks.Task> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null, System.Reactive.Concurrency.IScheduler? canExecuteScheduler = null) { }
+        public static ReactiveUI.ReactiveCommand<System.Reactive.Unit, System.Reactive.Unit> CreateFromTask(System.Func<System.Threading.CancellationToken, System.Threading.Tasks.Task> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null, System.Reactive.Concurrency.IScheduler? canExecuteScheduler = null) { }
+        public static ReactiveUI.ReactiveCommand<System.Reactive.Unit, TResult> CreateFromTask<TResult>(System.Func<System.Threading.Tasks.Task<TResult>> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null, System.Reactive.Concurrency.IScheduler? canExecuteScheduler = null) { }
+        public static ReactiveUI.ReactiveCommand<System.Reactive.Unit, TResult> CreateFromTask<TResult>(System.Func<System.Threading.CancellationToken, System.Threading.Tasks.Task<TResult>> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null, System.Reactive.Concurrency.IScheduler? canExecuteScheduler = null) { }
+        public static ReactiveUI.ReactiveCommand<TParam, System.Reactive.Unit> CreateFromTask<TParam>(System.Func<TParam, System.Threading.Tasks.Task> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null, System.Reactive.Concurrency.IScheduler? canExecuteScheduler = null) { }
+        public static ReactiveUI.ReactiveCommand<TParam, System.Reactive.Unit> CreateFromTask<TParam>(System.Func<TParam, System.Threading.CancellationToken, System.Threading.Tasks.Task> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null, System.Reactive.Concurrency.IScheduler? canExecuteScheduler = null) { }
+        public static ReactiveUI.ReactiveCommand<TParam, TResult> CreateFromTask<TParam, TResult>(System.Func<TParam, System.Threading.Tasks.Task<TResult>> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null, System.Reactive.Concurrency.IScheduler? canExecuteScheduler = null) { }
+        public static ReactiveUI.ReactiveCommand<TParam, TResult> CreateFromTask<TParam, TResult>(System.Func<TParam, System.Threading.CancellationToken, System.Threading.Tasks.Task<TResult>> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null, System.Reactive.Concurrency.IScheduler? canExecuteScheduler = null) { }
     }
     public abstract class ReactiveCommandBase<TParam, TResult> : ReactiveUI.IHandleObservableErrors, ReactiveUI.IReactiveCommand, System.IDisposable, System.IObservable<TResult>, System.Windows.Input.ICommand
     {
@@ -592,7 +592,7 @@ namespace ReactiveUI
     }
     public class ReactiveCommand<TParam, TResult> : ReactiveUI.ReactiveCommandBase<TParam, TResult>
     {
-        protected ReactiveCommand(System.Func<TParam, System.IObservable<TResult>> execute, System.IObservable<bool>? canExecute, System.Reactive.Concurrency.IScheduler? outputScheduler) { }
+        protected ReactiveCommand(System.Func<TParam, System.IObservable<TResult>> execute, System.IObservable<bool>? canExecute, System.Reactive.Concurrency.IScheduler? outputScheduler, System.Reactive.Concurrency.IScheduler? canExecuteScheduler) { }
         public override System.IObservable<bool> CanExecute { get; }
         public override System.IObservable<bool> IsExecuting { get; }
         public override System.IObservable<System.Exception> ThrownExceptions { get; }
diff --git a/src/ReactiveUI.Tests/API/ApiApprovalTests.ReactiveUI.netcoreapp3.1.approved.txt b/src/ReactiveUI.Tests/API/ApiApprovalTests.ReactiveUI.netcoreapp3.1.approved.txt
index eed9be0073..572e684b17 100644
--- a/src/ReactiveUI.Tests/API/ApiApprovalTests.ReactiveUI.netcoreapp3.1.approved.txt
+++ b/src/ReactiveUI.Tests/API/ApiApprovalTests.ReactiveUI.netcoreapp3.1.approved.txt
@@ -57,7 +57,7 @@ namespace ReactiveUI
     }
     public class CombinedReactiveCommand<TParam, TResult> : ReactiveUI.ReactiveCommandBase<TParam, System.Collections.Generic.IList<TResult>>
     {
-        protected CombinedReactiveCommand(System.Collections.Generic.IEnumerable<ReactiveUI.ReactiveCommandBase<TParam, TResult>> childCommands, System.IObservable<bool> canExecute, System.Reactive.Concurrency.IScheduler outputScheduler) { }
+        protected CombinedReactiveCommand(System.Collections.Generic.IEnumerable<ReactiveUI.ReactiveCommandBase<TParam, TResult>> childCommands, System.IObservable<bool> canExecute, System.Reactive.Concurrency.IScheduler outputScheduler, System.Reactive.Concurrency.IScheduler canExecuteScheduler) { }
         public override System.IObservable<bool> CanExecute { get; }
         public override System.IObservable<bool> IsExecuting { get; }
         public override System.IObservable<System.Exception> ThrownExceptions { get; }
@@ -548,21 +548,21 @@ namespace ReactiveUI
     }
     public static class ReactiveCommand
     {
-        public static ReactiveUI.ReactiveCommand<System.Reactive.Unit, System.Reactive.Unit> Create(System.Action execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null) { }
-        public static ReactiveUI.ReactiveCommand<TParam, System.Reactive.Unit> Create<TParam>(System.Action<TParam> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null) { }
-        public static ReactiveUI.ReactiveCommand<System.Reactive.Unit, TResult> Create<TResult>(System.Func<TResult> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null) { }
-        public static ReactiveUI.ReactiveCommand<TParam, TResult> Create<TParam, TResult>(System.Func<TParam, TResult> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null) { }
-        public static ReactiveUI.CombinedReactiveCommand<TParam, TResult> CreateCombined<TParam, TResult>(System.Collections.Generic.IEnumerable<ReactiveUI.ReactiveCommandBase<TParam, TResult>> childCommands, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null) { }
-        public static ReactiveUI.ReactiveCommand<System.Reactive.Unit, TResult> CreateFromObservable<TResult>(System.Func<System.IObservable<TResult>> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null) { }
-        public static ReactiveUI.ReactiveCommand<TParam, TResult> CreateFromObservable<TParam, TResult>(System.Func<TParam, System.IObservable<TResult>> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null) { }
-        public static ReactiveUI.ReactiveCommand<System.Reactive.Unit, System.Reactive.Unit> CreateFromTask(System.Func<System.Threading.Tasks.Task> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null) { }
-        public static ReactiveUI.ReactiveCommand<System.Reactive.Unit, System.Reactive.Unit> CreateFromTask(System.Func<System.Threading.CancellationToken, System.Threading.Tasks.Task> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null) { }
-        public static ReactiveUI.ReactiveCommand<System.Reactive.Unit, TResult> CreateFromTask<TResult>(System.Func<System.Threading.Tasks.Task<TResult>> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null) { }
-        public static ReactiveUI.ReactiveCommand<System.Reactive.Unit, TResult> CreateFromTask<TResult>(System.Func<System.Threading.CancellationToken, System.Threading.Tasks.Task<TResult>> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null) { }
-        public static ReactiveUI.ReactiveCommand<TParam, System.Reactive.Unit> CreateFromTask<TParam>(System.Func<TParam, System.Threading.Tasks.Task> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null) { }
-        public static ReactiveUI.ReactiveCommand<TParam, System.Reactive.Unit> CreateFromTask<TParam>(System.Func<TParam, System.Threading.CancellationToken, System.Threading.Tasks.Task> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null) { }
-        public static ReactiveUI.ReactiveCommand<TParam, TResult> CreateFromTask<TParam, TResult>(System.Func<TParam, System.Threading.Tasks.Task<TResult>> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null) { }
-        public static ReactiveUI.ReactiveCommand<TParam, TResult> CreateFromTask<TParam, TResult>(System.Func<TParam, System.Threading.CancellationToken, System.Threading.Tasks.Task<TResult>> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null) { }
+        public static ReactiveUI.ReactiveCommand<System.Reactive.Unit, System.Reactive.Unit> Create(System.Action execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null, System.Reactive.Concurrency.IScheduler? canExecuteScheduler = null) { }
+        public static ReactiveUI.ReactiveCommand<TParam, System.Reactive.Unit> Create<TParam>(System.Action<TParam> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null, System.Reactive.Concurrency.IScheduler? canExecuteScheduler = null) { }
+        public static ReactiveUI.ReactiveCommand<System.Reactive.Unit, TResult> Create<TResult>(System.Func<TResult> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null, System.Reactive.Concurrency.IScheduler? canExecuteScheduler = null) { }
+        public static ReactiveUI.ReactiveCommand<TParam, TResult> Create<TParam, TResult>(System.Func<TParam, TResult> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null, System.Reactive.Concurrency.IScheduler? canExecuteScheduler = null) { }
+        public static ReactiveUI.CombinedReactiveCommand<TParam, TResult> CreateCombined<TParam, TResult>(System.Collections.Generic.IEnumerable<ReactiveUI.ReactiveCommandBase<TParam, TResult>> childCommands, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null, System.Reactive.Concurrency.IScheduler? canExecuteScheduler = null) { }
+        public static ReactiveUI.ReactiveCommand<System.Reactive.Unit, TResult> CreateFromObservable<TResult>(System.Func<System.IObservable<TResult>> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null, System.Reactive.Concurrency.IScheduler? canExecuteScheduler = null) { }
+        public static ReactiveUI.ReactiveCommand<TParam, TResult> CreateFromObservable<TParam, TResult>(System.Func<TParam, System.IObservable<TResult>> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null, System.Reactive.Concurrency.IScheduler? canExecuteScheduler = null) { }
+        public static ReactiveUI.ReactiveCommand<System.Reactive.Unit, System.Reactive.Unit> CreateFromTask(System.Func<System.Threading.Tasks.Task> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null, System.Reactive.Concurrency.IScheduler? canExecuteScheduler = null) { }
+        public static ReactiveUI.ReactiveCommand<System.Reactive.Unit, System.Reactive.Unit> CreateFromTask(System.Func<System.Threading.CancellationToken, System.Threading.Tasks.Task> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null, System.Reactive.Concurrency.IScheduler? canExecuteScheduler = null) { }
+        public static ReactiveUI.ReactiveCommand<System.Reactive.Unit, TResult> CreateFromTask<TResult>(System.Func<System.Threading.Tasks.Task<TResult>> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null, System.Reactive.Concurrency.IScheduler? canExecuteScheduler = null) { }
+        public static ReactiveUI.ReactiveCommand<System.Reactive.Unit, TResult> CreateFromTask<TResult>(System.Func<System.Threading.CancellationToken, System.Threading.Tasks.Task<TResult>> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null, System.Reactive.Concurrency.IScheduler? canExecuteScheduler = null) { }
+        public static ReactiveUI.ReactiveCommand<TParam, System.Reactive.Unit> CreateFromTask<TParam>(System.Func<TParam, System.Threading.Tasks.Task> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null, System.Reactive.Concurrency.IScheduler? canExecuteScheduler = null) { }
+        public static ReactiveUI.ReactiveCommand<TParam, System.Reactive.Unit> CreateFromTask<TParam>(System.Func<TParam, System.Threading.CancellationToken, System.Threading.Tasks.Task> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null, System.Reactive.Concurrency.IScheduler? canExecuteScheduler = null) { }
+        public static ReactiveUI.ReactiveCommand<TParam, TResult> CreateFromTask<TParam, TResult>(System.Func<TParam, System.Threading.Tasks.Task<TResult>> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null, System.Reactive.Concurrency.IScheduler? canExecuteScheduler = null) { }
+        public static ReactiveUI.ReactiveCommand<TParam, TResult> CreateFromTask<TParam, TResult>(System.Func<TParam, System.Threading.CancellationToken, System.Threading.Tasks.Task<TResult>> execute, System.IObservable<bool>? canExecute = null, System.Reactive.Concurrency.IScheduler? outputScheduler = null, System.Reactive.Concurrency.IScheduler? canExecuteScheduler = null) { }
     }
     public abstract class ReactiveCommandBase<TParam, TResult> : ReactiveUI.IHandleObservableErrors, ReactiveUI.IReactiveCommand, System.IDisposable, System.IObservable<TResult>, System.Windows.Input.ICommand
     {
@@ -590,7 +590,7 @@ namespace ReactiveUI
     }
     public class ReactiveCommand<TParam, TResult> : ReactiveUI.ReactiveCommandBase<TParam, TResult>
     {
-        protected ReactiveCommand(System.Func<TParam, System.IObservable<TResult>> execute, System.IObservable<bool>? canExecute, System.Reactive.Concurrency.IScheduler? outputScheduler) { }
+        protected ReactiveCommand(System.Func<TParam, System.IObservable<TResult>> execute, System.IObservable<bool>? canExecute, System.Reactive.Concurrency.IScheduler? outputScheduler, System.Reactive.Concurrency.IScheduler? canExecuteScheduler) { }
         public override System.IObservable<bool> CanExecute { get; }
         public override System.IObservable<bool> IsExecuting { get; }
         public override System.IObservable<System.Exception> ThrownExceptions { get; }
diff --git a/src/ReactiveUI.Tests/Commands/ReactiveCommandTest.cs b/src/ReactiveUI.Tests/Commands/ReactiveCommandTest.cs
index d0bf4d2e94..ad832aba35 100644
--- a/src/ReactiveUI.Tests/Commands/ReactiveCommandTest.cs
+++ b/src/ReactiveUI.Tests/Commands/ReactiveCommandTest.cs
@@ -985,7 +985,7 @@ public void InvokeCommandAgainstReactiveCommandSwallowsExceptions()
         public void InvokeCommandWorksEvenIfTheSourceIsCold()
         {
             var executionCount = 0;
-            ReactiveCommand<Unit, int> fixture = ReactiveCommand.Create(() => ++executionCount, outputScheduler: ImmediateScheduler.Instance);
+            ReactiveCommand<Unit, int> fixture = ReactiveCommand.Create(() => ++executionCount, outputScheduler: ImmediateScheduler.Instance, canExecuteScheduler: ImmediateScheduler.Instance);
             var source = Observable.Return(Unit.Default);
             source.InvokeCommand(fixture);
 
diff --git a/src/ReactiveUI/ReactiveCommand/CombinedReactiveCommand.cs b/src/ReactiveUI/ReactiveCommand/CombinedReactiveCommand.cs
index bac376f315..1644ddbca0 100644
--- a/src/ReactiveUI/ReactiveCommand/CombinedReactiveCommand.cs
+++ b/src/ReactiveUI/ReactiveCommand/CombinedReactiveCommand.cs
@@ -48,12 +48,16 @@ public class CombinedReactiveCommand<TParam, TResult> : ReactiveCommandBase<TPar
         /// <param name="childCommands">The child commands which will be executed.</param>
         /// <param name="canExecute">A observable when the command can be executed.</param>
         /// <param name="outputScheduler">The scheduler where to dispatch the output from the command.</param>
+        /// <param name="canExecuteScheduler">
+        /// An optional scheduler that is used for CanExecute and IsExecuting events. Defaults to <c>RxApp.MainThreadScheduler</c>.
+        /// </param>
         /// <exception cref="ArgumentNullException">Fires when required arguments are null.</exception>
         /// <exception cref="ArgumentException">Fires if the child commands container is empty.</exception>
         protected internal CombinedReactiveCommand(
             IEnumerable<ReactiveCommandBase<TParam, TResult>> childCommands,
             IObservable<bool> canExecute,
-            IScheduler outputScheduler)
+            IScheduler outputScheduler,
+            IScheduler canExecuteScheduler)
         {
             if (childCommands is null)
             {
@@ -70,6 +74,11 @@ public class CombinedReactiveCommand<TParam, TResult> : ReactiveCommandBase<TPar
                 throw new ArgumentNullException(nameof(outputScheduler));
             }
 
+            if (canExecuteScheduler is null)
+            {
+                throw new ArgumentNullException(nameof(canExecuteScheduler));
+            }
+
             var childCommandsArray = childCommands.ToArray();
 
             if (childCommandsArray.Length == 0)
@@ -92,7 +101,8 @@ public class CombinedReactiveCommand<TParam, TResult> : ReactiveCommandBase<TPar
                 .CombineLatest(canChildrenExecute, (ce, cce) => ce && cce)
                 .DistinctUntilChanged()
                 .Replay(1)
-                .RefCount();
+                .RefCount()
+                .ObserveOn(canExecuteScheduler);
 
             _exceptionsSubscription = childCommandsArray.Select(x => x.ThrownExceptions)
                                                         .Merge()
@@ -104,7 +114,8 @@ public class CombinedReactiveCommand<TParam, TResult> : ReactiveCommandBase<TPar
                         .Select(x => x.Execute(param))
                         .CombineLatest(),
                 combinedCanExecute,
-                outputScheduler);
+                outputScheduler,
+                canExecuteScheduler);
 
             // we already handle exceptions on individual child commands above, but the same exception
             // will tick through innerCommand. Therefore, we need to ensure we ignore it or the default
diff --git a/src/ReactiveUI/ReactiveCommand/ReactiveCommand.cs b/src/ReactiveUI/ReactiveCommand/ReactiveCommand.cs
index 468db3b9cb..77ecb98799 100644
--- a/src/ReactiveUI/ReactiveCommand/ReactiveCommand.cs
+++ b/src/ReactiveUI/ReactiveCommand/ReactiveCommand.cs
@@ -85,13 +85,17 @@ public static class ReactiveCommand
         /// <param name="outputScheduler">
         /// An optional scheduler that is used to surface events. Defaults to <c>RxApp.MainThreadScheduler</c>.
         /// </param>
+        /// <param name="canExecuteScheduler">
+        /// An optional scheduler that is used for CanExecute and IsExecuting events. Defaults to <c>RxApp.MainThreadScheduler</c>.
+        /// </param>
         /// <returns>
         /// The <c>ReactiveCommand</c> instance.
         /// </returns>
         public static ReactiveCommand<Unit, Unit> Create(
             Action execute,
             IObservable<bool>? canExecute = null,
-            IScheduler? outputScheduler = null)
+            IScheduler? outputScheduler = null,
+            IScheduler? canExecuteScheduler = null)
         {
             if (execute is null)
             {
@@ -108,7 +112,8 @@ public static class ReactiveCommand
                         return Disposable.Empty;
                     }),
                 canExecute ?? Observables.True,
-                outputScheduler ?? RxApp.MainThreadScheduler);
+                outputScheduler ?? RxApp.MainThreadScheduler,
+                canExecuteScheduler ?? RxApp.MainThreadScheduler);
         }
 
         /// <summary>
@@ -124,6 +129,9 @@ public static class ReactiveCommand
         /// <param name="outputScheduler">
         /// An optional scheduler that is used to surface events. Defaults to <c>RxApp.MainThreadScheduler</c>.
         /// </param>
+        /// <param name="canExecuteScheduler">
+        /// An optional scheduler that is used for CanExecute and IsExecuting events. Defaults to <c>RxApp.MainThreadScheduler</c>.
+        /// </param>
         /// <returns>
         /// The <c>ReactiveCommand</c> instance.
         /// </returns>
@@ -133,7 +141,8 @@ public static class ReactiveCommand
         public static ReactiveCommand<Unit, TResult> Create<TResult>(
             Func<TResult> execute,
             IObservable<bool>? canExecute = null,
-            IScheduler? outputScheduler = null)
+            IScheduler? outputScheduler = null,
+            IScheduler? canExecuteScheduler = null)
         {
             if (execute is null)
             {
@@ -149,7 +158,8 @@ public static class ReactiveCommand
                         return Disposable.Empty;
                     }),
                 canExecute ?? Observables.True,
-                outputScheduler ?? RxApp.MainThreadScheduler);
+                outputScheduler ?? RxApp.MainThreadScheduler,
+                canExecuteScheduler ?? RxApp.MainThreadScheduler);
         }
 
         /// <summary>
@@ -164,6 +174,9 @@ public static class ReactiveCommand
         /// <param name="outputScheduler">
         /// An optional scheduler that is used to surface events. Defaults to <c>RxApp.MainThreadScheduler</c>.
         /// </param>
+        /// <param name="canExecuteScheduler">
+        /// An optional scheduler that is used for CanExecute and IsExecuting events. Defaults to <c>RxApp.MainThreadScheduler</c>.
+        /// </param>
         /// <returns>
         /// The <c>ReactiveCommand</c> instance.
         /// </returns>
@@ -173,7 +186,8 @@ public static class ReactiveCommand
         public static ReactiveCommand<TParam, Unit> Create<TParam>(
             Action<TParam> execute,
             IObservable<bool>? canExecute = null,
-            IScheduler? outputScheduler = null)
+            IScheduler? outputScheduler = null,
+            IScheduler? canExecuteScheduler = null)
         {
             if (execute is null)
             {
@@ -190,7 +204,8 @@ public static class ReactiveCommand
                         return Disposable.Empty;
                     }),
                 canExecute ?? Observables.True,
-                outputScheduler ?? RxApp.MainThreadScheduler);
+                outputScheduler ?? RxApp.MainThreadScheduler,
+                canExecuteScheduler ?? RxApp.MainThreadScheduler);
         }
 
         /// <summary>
@@ -206,6 +221,9 @@ public static class ReactiveCommand
         /// <param name="outputScheduler">
         /// An optional scheduler that is used to surface events. Defaults to <c>RxApp.MainThreadScheduler</c>.
         /// </param>
+        /// <param name="canExecuteScheduler">
+        /// An optional scheduler that is used for CanExecute and IsExecuting events. Defaults to <c>RxApp.MainThreadScheduler</c>.
+        /// </param>
         /// <returns>
         /// The <c>ReactiveCommand</c> instance.
         /// </returns>
@@ -218,7 +236,8 @@ public static class ReactiveCommand
         public static ReactiveCommand<TParam, TResult> Create<TParam, TResult>(
             Func<TParam, TResult> execute,
             IObservable<bool>? canExecute = null,
-            IScheduler? outputScheduler = null)
+            IScheduler? outputScheduler = null,
+            IScheduler? canExecuteScheduler = null)
         {
             if (execute is null)
             {
@@ -234,7 +253,8 @@ public static class ReactiveCommand
                         return Disposable.Empty;
                     }),
                 canExecute ?? Observables.True,
-                outputScheduler ?? RxApp.MainThreadScheduler);
+                outputScheduler ?? RxApp.MainThreadScheduler,
+                canExecuteScheduler ?? RxApp.MainThreadScheduler);
         }
 
         /// <summary>
@@ -250,6 +270,9 @@ public static class ReactiveCommand
         /// <param name="outputScheduler">
         /// An optional scheduler that is used to surface events. Defaults to <c>RxApp.MainThreadScheduler</c>.
         /// </param>
+        /// <param name="canExecuteScheduler">
+        /// An optional scheduler that is used for CanExecute and IsExecuting events. Defaults to <c>RxApp.MainThreadScheduler</c>.
+        /// </param>
         /// <returns>
         /// The <c>CombinedReactiveCommand</c> instance.
         /// </returns>
@@ -262,14 +285,15 @@ public static class ReactiveCommand
         public static CombinedReactiveCommand<TParam, TResult> CreateCombined<TParam, TResult>(
             IEnumerable<ReactiveCommandBase<TParam, TResult>> childCommands,
             IObservable<bool>? canExecute = null,
-            IScheduler? outputScheduler = null)
+            IScheduler? outputScheduler = null,
+            IScheduler? canExecuteScheduler = null)
         {
             if (childCommands is null)
             {
                 throw new ArgumentNullException(nameof(childCommands));
             }
 
-            return new CombinedReactiveCommand<TParam, TResult>(childCommands, canExecute ?? Observables.True, outputScheduler ?? RxApp.MainThreadScheduler);
+            return new CombinedReactiveCommand<TParam, TResult>(childCommands, canExecute ?? Observables.True, outputScheduler ?? RxApp.MainThreadScheduler, canExecuteScheduler ?? RxApp.MainThreadScheduler);
         }
 
         /// <summary>
@@ -284,6 +308,9 @@ public static class ReactiveCommand
         /// <param name="outputScheduler">
         /// An optional scheduler that is used to surface events. Defaults to <c>RxApp.MainThreadScheduler</c>.
         /// </param>
+        /// <param name="canExecuteScheduler">
+        /// An optional scheduler that is used for CanExecute and IsExecuting events. Defaults to <c>RxApp.MainThreadScheduler</c>.
+        /// </param>
         /// <returns>
         /// The <c>ReactiveCommand</c> instance.
         /// </returns>
@@ -293,7 +320,8 @@ public static class ReactiveCommand
         public static ReactiveCommand<Unit, TResult> CreateFromObservable<TResult>(
             Func<IObservable<TResult>> execute,
             IObservable<bool>? canExecute = null,
-            IScheduler? outputScheduler = null)
+            IScheduler? outputScheduler = null,
+            IScheduler? canExecuteScheduler = null)
         {
             if (execute is null)
             {
@@ -303,7 +331,8 @@ public static class ReactiveCommand
             return new ReactiveCommand<Unit, TResult>(
                 _ => execute(),
                 canExecute ?? Observables.True,
-                outputScheduler ?? RxApp.MainThreadScheduler);
+                outputScheduler ?? RxApp.MainThreadScheduler,
+                canExecuteScheduler ?? RxApp.MainThreadScheduler);
         }
 
         /// <summary>
@@ -318,6 +347,9 @@ public static class ReactiveCommand
         /// <param name="outputScheduler">
         /// An optional scheduler that is used to surface events. Defaults to <c>RxApp.MainThreadScheduler</c>.
         /// </param>
+        /// <param name="canExecuteScheduler">
+        /// An optional scheduler that is used for CanExecute and IsExecuting events. Defaults to <c>RxApp.MainThreadScheduler</c>.
+        /// </param>
         /// <returns>
         /// The <c>ReactiveCommand</c> instance.
         /// </returns>
@@ -330,7 +362,8 @@ public static class ReactiveCommand
         public static ReactiveCommand<TParam, TResult> CreateFromObservable<TParam, TResult>(
             Func<TParam, IObservable<TResult>> execute,
             IObservable<bool>? canExecute = null,
-            IScheduler? outputScheduler = null)
+            IScheduler? outputScheduler = null,
+            IScheduler? canExecuteScheduler = null)
         {
             if (execute is null)
             {
@@ -340,7 +373,8 @@ public static class ReactiveCommand
             return new ReactiveCommand<TParam, TResult>(
                 execute,
                 canExecute ?? Observables.True,
-                outputScheduler ?? RxApp.MainThreadScheduler);
+                outputScheduler ?? RxApp.MainThreadScheduler,
+                canExecuteScheduler ?? RxApp.MainThreadScheduler);
         }
 
         /// <summary>
@@ -355,6 +389,9 @@ public static class ReactiveCommand
         /// <param name="outputScheduler">
         /// An optional scheduler that is used to surface events. Defaults to <c>RxApp.MainThreadScheduler</c>.
         /// </param>
+        /// <param name="canExecuteScheduler">
+        /// An optional scheduler that is used for CanExecute and IsExecuting events. Defaults to <c>RxApp.MainThreadScheduler</c>.
+        /// </param>
         /// <returns>
         /// The <c>ReactiveCommand</c> instance.
         /// </returns>
@@ -364,14 +401,15 @@ public static class ReactiveCommand
         public static ReactiveCommand<Unit, TResult> CreateFromTask<TResult>(
             Func<Task<TResult>> execute,
             IObservable<bool>? canExecute = null,
-            IScheduler? outputScheduler = null)
+            IScheduler? outputScheduler = null,
+            IScheduler? canExecuteScheduler = null)
         {
             if (execute is null)
             {
                 throw new ArgumentNullException(nameof(execute));
             }
 
-            return CreateFromObservable(() => execute().ToObservable(), canExecute, outputScheduler);
+            return CreateFromObservable(() => execute().ToObservable(), canExecute, outputScheduler, canExecuteScheduler);
         }
 
         /// <summary>
@@ -386,6 +424,9 @@ public static class ReactiveCommand
         /// <param name="outputScheduler">
         /// An optional scheduler that is used to surface events. Defaults to <c>RxApp.MainThreadScheduler</c>.
         /// </param>
+        /// <param name="canExecuteScheduler">
+        /// An optional scheduler that is used for CanExecute and IsExecuting events. Defaults to <c>RxApp.MainThreadScheduler</c>.
+        /// </param>
         /// <returns>
         /// The <c>ReactiveCommand</c> instance.
         /// </returns>
@@ -395,14 +436,15 @@ public static class ReactiveCommand
         public static ReactiveCommand<Unit, TResult> CreateFromTask<TResult>(
             Func<CancellationToken, Task<TResult>> execute,
             IObservable<bool>? canExecute = null,
-            IScheduler? outputScheduler = null)
+            IScheduler? outputScheduler = null,
+            IScheduler? canExecuteScheduler = null)
         {
             if (execute is null)
             {
                 throw new ArgumentNullException(nameof(execute));
             }
 
-            return CreateFromObservable(() => Observable.FromAsync(execute), canExecute, outputScheduler);
+            return CreateFromObservable(() => Observable.FromAsync(execute), canExecute, outputScheduler, canExecuteScheduler);
         }
 
         /// <summary>
@@ -417,20 +459,24 @@ public static class ReactiveCommand
         /// <param name="outputScheduler">
         /// An optional scheduler that is used to surface events. Defaults to <c>RxApp.MainThreadScheduler</c>.
         /// </param>
+        /// <param name="canExecuteScheduler">
+        /// An optional scheduler that is used for CanExecute and IsExecuting events. Defaults to <c>RxApp.MainThreadScheduler</c>.
+        /// </param>
         /// <returns>
         /// The <c>ReactiveCommand</c> instance.
         /// </returns>
         public static ReactiveCommand<Unit, Unit> CreateFromTask(
             Func<Task> execute,
             IObservable<bool>? canExecute = null,
-            IScheduler? outputScheduler = null)
+            IScheduler? outputScheduler = null,
+            IScheduler? canExecuteScheduler = null)
         {
             if (execute is null)
             {
                 throw new ArgumentNullException(nameof(execute));
             }
 
-            return CreateFromObservable(() => execute().ToObservable(), canExecute, outputScheduler);
+            return CreateFromObservable(() => execute().ToObservable(), canExecute, outputScheduler, canExecuteScheduler);
         }
 
         /// <summary>
@@ -445,20 +491,24 @@ public static class ReactiveCommand
         /// <param name="outputScheduler">
         /// An optional scheduler that is used to surface events. Defaults to <c>RxApp.MainThreadScheduler</c>.
         /// </param>
+        /// <param name="canExecuteScheduler">
+        /// An optional scheduler that is used for CanExecute and IsExecuting events. Defaults to <c>RxApp.MainThreadScheduler</c>.
+        /// </param>
         /// <returns>
         /// The <c>ReactiveCommand</c> instance.
         /// </returns>
         public static ReactiveCommand<Unit, Unit> CreateFromTask(
             Func<CancellationToken, Task> execute,
             IObservable<bool>? canExecute = null,
-            IScheduler? outputScheduler = null)
+            IScheduler? outputScheduler = null,
+            IScheduler? canExecuteScheduler = null)
         {
             if (execute is null)
             {
                 throw new ArgumentNullException(nameof(execute));
             }
 
-            return CreateFromObservable(() => Observable.FromAsync(execute), canExecute, outputScheduler);
+            return CreateFromObservable(() => Observable.FromAsync(execute), canExecute, outputScheduler, canExecuteScheduler);
         }
 
         /// <summary>
@@ -473,6 +523,9 @@ public static class ReactiveCommand
         /// <param name="outputScheduler">
         /// An optional scheduler that is used to surface events. Defaults to <c>RxApp.MainThreadScheduler</c>.
         /// </param>
+        /// <param name="canExecuteScheduler">
+        /// An optional scheduler that is used for CanExecute and IsExecuting events. Defaults to <c>RxApp.MainThreadScheduler</c>.
+        /// </param>
         /// <returns>
         /// The <c>ReactiveCommand</c> instance.
         /// </returns>
@@ -485,7 +538,8 @@ public static class ReactiveCommand
         public static ReactiveCommand<TParam, TResult> CreateFromTask<TParam, TResult>(
             Func<TParam, Task<TResult>> execute,
             IObservable<bool>? canExecute = null,
-            IScheduler? outputScheduler = null)
+            IScheduler? outputScheduler = null,
+            IScheduler? canExecuteScheduler = null)
         {
             if (execute is null)
             {
@@ -495,7 +549,8 @@ public static class ReactiveCommand
             return CreateFromObservable<TParam, TResult>(
                 param => execute(param).ToObservable(),
                 canExecute,
-                outputScheduler);
+                outputScheduler,
+                canExecuteScheduler);
         }
 
         /// <summary>
@@ -510,6 +565,9 @@ public static class ReactiveCommand
         /// <param name="outputScheduler">
         /// An optional scheduler that is used to surface events. Defaults to <c>RxApp.MainThreadScheduler</c>.
         /// </param>
+        /// <param name="canExecuteScheduler">
+        /// An optional scheduler that is used for CanExecute and IsExecuting events. Defaults to <c>RxApp.MainThreadScheduler</c>.
+        /// </param>
         /// <returns>
         /// The <c>ReactiveCommand</c> instance.
         /// </returns>
@@ -522,7 +580,8 @@ public static class ReactiveCommand
         public static ReactiveCommand<TParam, TResult> CreateFromTask<TParam, TResult>(
             Func<TParam, CancellationToken, Task<TResult>> execute,
             IObservable<bool>? canExecute = null,
-            IScheduler? outputScheduler = null)
+            IScheduler? outputScheduler = null,
+            IScheduler? canExecuteScheduler = null)
         {
             if (execute is null)
             {
@@ -532,7 +591,8 @@ public static class ReactiveCommand
             return CreateFromObservable<TParam, TResult>(
                 param => Observable.FromAsync(ct => execute(param, ct)),
                 canExecute,
-                outputScheduler);
+                outputScheduler,
+                canExecuteScheduler);
         }
 
         /// <summary>
@@ -547,6 +607,9 @@ public static class ReactiveCommand
         /// <param name="outputScheduler">
         /// An optional scheduler that is used to surface events. Defaults to <c>RxApp.MainThreadScheduler</c>.
         /// </param>
+        /// <param name="canExecuteScheduler">
+        /// An optional scheduler that is used for CanExecute and IsExecuting events. Defaults to <c>RxApp.MainThreadScheduler</c>.
+        /// </param>
         /// <returns>
         /// The <c>ReactiveCommand</c> instance.
         /// </returns>
@@ -556,7 +619,8 @@ public static class ReactiveCommand
         public static ReactiveCommand<TParam, Unit> CreateFromTask<TParam>(
             Func<TParam, Task> execute,
             IObservable<bool>? canExecute = null,
-            IScheduler? outputScheduler = null)
+            IScheduler? outputScheduler = null,
+            IScheduler? canExecuteScheduler = null)
         {
             if (execute is null)
             {
@@ -566,7 +630,8 @@ public static class ReactiveCommand
             return CreateFromObservable<TParam, Unit>(
                 param => execute(param).ToObservable(),
                 canExecute,
-                outputScheduler);
+                outputScheduler,
+                canExecuteScheduler);
         }
 
         /// <summary>
@@ -581,6 +646,9 @@ public static class ReactiveCommand
         /// <param name="outputScheduler">
         /// An optional scheduler that is used to surface events. Defaults to <c>RxApp.MainThreadScheduler</c>.
         /// </param>
+        /// <param name="canExecuteScheduler">
+        /// An optional scheduler that is used for CanExecute and IsExecuting events. Defaults to <c>RxApp.MainThreadScheduler</c>.
+        /// </param>
         /// <returns>
         /// The <c>ReactiveCommand</c> instance.
         /// </returns>
@@ -590,7 +658,8 @@ public static class ReactiveCommand
         public static ReactiveCommand<TParam, Unit> CreateFromTask<TParam>(
             Func<TParam, CancellationToken, Task> execute,
             IObservable<bool>? canExecute = null,
-            IScheduler? outputScheduler = null)
+            IScheduler? outputScheduler = null,
+            IScheduler? canExecuteScheduler = null)
         {
             if (execute is null)
             {
@@ -600,7 +669,8 @@ public static class ReactiveCommand
             return CreateFromObservable<TParam, Unit>(
                 param => Observable.FromAsync(ct => execute(param, ct)),
                 canExecute,
-                outputScheduler);
+                outputScheduler,
+                canExecuteScheduler);
         }
     }
 
@@ -640,6 +710,8 @@ public class ReactiveCommand<TParam, TResult> : ReactiveCommandBase<TParam, TRes
 
         private readonly IScheduler _outputScheduler;
 
+        private readonly IScheduler _canExecuteScheduler;
+
         private readonly IObservable<TResult> _results;
 
         private readonly ISubject<ExecutionInfo, ExecutionInfo> _synchronizedExecutionInfo;
@@ -650,11 +722,13 @@ public class ReactiveCommand<TParam, TResult> : ReactiveCommandBase<TParam, TRes
         /// <param name="execute">The Func to perform when the command is executed.</param>
         /// <param name="canExecute">A observable which has a value if the command can execute.</param>
         /// <param name="outputScheduler">The scheduler where to send output after the main execution.</param>
+        /// <param name="canExecuteScheduler">The scheduler for CanExecute and IsExcuting.</param>
         /// <exception cref="ArgumentNullException">Thrown if any dependent parameters are null.</exception>
         protected internal ReactiveCommand(
             Func<TParam, IObservable<TResult>> execute,
             IObservable<bool>? canExecute,
-            IScheduler? outputScheduler)
+            IScheduler? outputScheduler,
+            IScheduler? canExecuteScheduler)
         {
             if (canExecute is null)
             {
@@ -663,6 +737,7 @@ public class ReactiveCommand<TParam, TResult> : ReactiveCommandBase<TParam, TRes
 
             _execute = execute ?? throw new ArgumentNullException(nameof(execute));
             _outputScheduler = outputScheduler ?? throw new ArgumentNullException(nameof(outputScheduler));
+            _canExecuteScheduler = canExecuteScheduler ?? throw new ArgumentNullException(nameof(canExecuteScheduler));
             _exceptions = new ScheduledSubject<Exception>(outputScheduler, RxApp.DefaultExceptionHandler);
             _executionInfo = new Subject<ExecutionInfo>();
             _synchronizedExecutionInfo = Subject.Synchronize(_executionInfo, outputScheduler);
@@ -676,8 +751,10 @@ public class ReactiveCommand<TParam, TResult> : ReactiveCommandBase<TParam, TRes
                          ExecutionDemarcation.End => acc - 1,
                          _ => acc
                      };
-                 }).Select(inFlightCount => inFlightCount > 0).StartWith(false)
-                 .DistinctUntilChanged().Replay(1)
+                 }).Select(inFlightCount => inFlightCount > 0)
+                 .StartWith(false)
+                 .DistinctUntilChanged()
+                 .Replay(1)
                  .RefCount();
 
             _canExecute = canExecute.Catch<bool, Exception>(
@@ -685,14 +762,17 @@ public class ReactiveCommand<TParam, TResult> : ReactiveCommandBase<TParam, TRes
                 {
                     _exceptions.OnNext(ex);
                     return Observables.False;
-                }).StartWith(false).CombineLatest(_isExecuting, (canEx, isEx) => canEx && !isEx)
+                }).StartWith(false)
+                .CombineLatest(_isExecuting, (canEx, isEx) => canEx && !isEx)
                 .DistinctUntilChanged()
-                .Replay(1).RefCount();
+                .Replay(1)
+                .RefCount()
+                .ObserveOn(_canExecuteScheduler);
 
             _results = _synchronizedExecutionInfo.Where(x => x.Demarcation == ExecutionDemarcation.Result)
                 .Select(x => x.Result);
 
-            _canExecuteSubscription = _canExecute.ObserveOn(RxApp.MainThreadScheduler).Subscribe(OnCanExecuteChanged);
+            _canExecuteSubscription = _canExecute.Subscribe(OnCanExecuteChanged);
         }
 
         private enum ExecutionDemarcation
@@ -732,7 +812,8 @@ public override IObservable<TResult> Execute(TParam parameter)
                         return Observable.Throw<TResult>(ex);
                     }).Finally(() => _synchronizedExecutionInfo.OnNext(ExecutionInfo.CreateEnd()))
                 .PublishLast()
-                .RefCount().ObserveOn(_outputScheduler);
+                .RefCount()
+                .ObserveOn(_outputScheduler);
             }
             catch (Exception ex)
             {
@@ -760,7 +841,8 @@ public override IObservable<TResult> Execute()
                                          return Observable.Throw<TResult>(ex);
                                      }).Finally(() => _synchronizedExecutionInfo.OnNext(ExecutionInfo.CreateEnd()))
                                  .PublishLast()
-                                 .RefCount().ObserveOn(_outputScheduler);
+                                 .RefCount()
+                                 .ObserveOn(_outputScheduler);
             }
             catch (Exception ex)
             {
diff --git a/src/ReactiveUI/ReactiveCommand/ReactiveCommandBase.cs b/src/ReactiveUI/ReactiveCommand/ReactiveCommandBase.cs
index 74cf2b01f8..455235557a 100644
--- a/src/ReactiveUI/ReactiveCommand/ReactiveCommandBase.cs
+++ b/src/ReactiveUI/ReactiveCommand/ReactiveCommandBase.cs
@@ -30,7 +30,7 @@ namespace ReactiveUI
     /// <para>
     /// To create an instance of <c>ReactiveCommand</c>, call one of the static creation methods defined by this class.
     /// <see cref="ReactiveCommand.Create"/> can be used when your execution logic is synchronous.
-    /// <see cref="ReactiveCommand.CreateFromObservable{TResult}(Func{IObservable{TResult}}, IObservable{bool}, IScheduler)"/> and
+    /// <see cref="ReactiveCommand.CreateFromObservable{TResult}(Func{IObservable{TResult}}, IObservable{bool}, IScheduler, IScheduler)"/> and
     /// <see cref="ReactiveCommand.CreateFromTask(Func{Task}, IObservable{bool}, IScheduler)"/> (and overloads) can be used for asynchronous
     /// execution logic. Optionally, you can provide an observable that governs the availability of the command for execution,
     /// as well as a scheduler to which events will be delivered.