Extending RxCommand

Yeah69 · Oct 31, 2020 · 4389392 · 4389392
1 parent ed3ca89
commit 4389392
Show file tree

Hide file tree

Showing 2 changed files with 76 additions and 1 deletion.
diff --git a/MrMeeseeks.Windows/RxCommand.cs b/MrMeeseeks.Windows/RxCommand.cs
@@ -23,12 +23,20 @@ public static class RxCommand
         public static IRxCommand CanNeverExecute() => RxCommandCanNeverExecute.Instance;
 
         public static IDisposableRxCommand CanAlwaysExecute() => new RxCommandCanAlwaysExecute();
+
+        public static IRxCommand CanAlwaysExecuteNeverEmits() => RxCommandCanAlwaysExecuteNeverEmits.Instance;
 
         public static IDisposableRxCommand CallerDeterminedCanExecute(IObservable<bool> observeCanExecute, bool initialCanExecute) =>
             new RxCommandCallerDeterminedCanExecute(observeCanExecute, initialCanExecute);
 
         public static IDisposableRxCommand CallerDeterminedCanExecute(IObservable<bool> observeCanExecute) =>
             new RxCommandCallerDeterminedCanExecute(observeCanExecute, false);
+
+        public static IDisposableRxCommand CallerDeterminedCanExecuteNeverEmits(IObservable<bool> observeCanExecute, bool initialCanExecute) =>
+            new RxCommandCallerDeterminedCanExecuteNeverEmits(observeCanExecute, initialCanExecute);
+
+        public static IDisposableRxCommand CallerDeterminedCanExecuteNeverEmits(IObservable<bool> observeCanExecute) =>
+            new RxCommandCallerDeterminedCanExecuteNeverEmits(observeCanExecute, false);
     }
 
     public static class ObservableRxCommandExtensions
@@ -40,6 +48,14 @@ public static class ObservableRxCommandExtensions
 
         public static IDisposableRxCommand AsCanExecuteForRxCommand(this IObservable<bool> observeCanExecute) =>
             RxCommand.CallerDeterminedCanExecute(observeCanExecute);
+
+        public static IDisposableRxCommand AsCanExecuteForRxCommandThatNeverEmits(
+            this IObservable<bool> observeCanExecute,
+            bool initialCanExecute) =>
+            RxCommand.CallerDeterminedCanExecuteNeverEmits(observeCanExecute, initialCanExecute);
+
+        public static IDisposableRxCommand AsCanExecuteForRxCommandThatNeverEmits(this IObservable<bool> observeCanExecute) =>
+            RxCommand.CallerDeterminedCanExecuteNeverEmits(observeCanExecute);
     }
 
     internal class RxCommandCanNeverExecute : IRxCommand
@@ -83,6 +99,29 @@ internal class RxCommandCanAlwaysExecute : IDisposableRxCommand
         public IObservable<object> Observe => _commandTriggering.AsObservable();
     }
 
+    internal class RxCommandCanAlwaysExecuteNeverEmits : IRxCommand
+    {
+        static RxCommandCanAlwaysExecuteNeverEmits()
+        {
+            Instance = new RxCommandCanAlwaysExecuteNeverEmits();
+        }
+
+        internal static IRxCommand Instance { get; }
+
+        private RxCommandCanAlwaysExecuteNeverEmits()
+        {}
+
+        public bool CanExecute(object parameter) => true;
+
+        public void Execute(object parameter) {}
+
+#pragma warning disable 67 // CanExecuteChange never used, because CanExecute never changes
+        public event EventHandler? CanExecuteChanged;
+#pragma warning restore 67
+
+        public IObservable<object> Observe => Observable.Never<object>();
+    }
+
     internal class RxCommandCallerDeterminedCanExecute : IDisposableRxCommand
     {
         private readonly Subject<object> _commandTriggering = new Subject<object>();
@@ -116,4 +155,33 @@ public void Dispose()
 
         public IObservable<object> Observe => _commandTriggering.AsObservable();
     }
+
+    internal class RxCommandCallerDeterminedCanExecuteNeverEmits : IDisposableRxCommand
+    {
+        private readonly IDisposable _canExecuteSubscription;
+
+        private bool _canExecute;
+
+        internal RxCommandCallerDeterminedCanExecuteNeverEmits(
+            IObservable<bool> observeCanExecute,
+            bool initialCanExecute)
+        {
+            _canExecute = initialCanExecute;
+            _canExecuteSubscription = observeCanExecute
+                .Subscribe(b =>
+                {
+                    _canExecute = b;
+                    CanExecuteChanged?.Invoke(this, EventArgs.Empty);
+                });
+        }
+
+        public bool CanExecute(object parameter) => _canExecute;
+
+        public void Execute(object parameter) {}
+
+        public event EventHandler? CanExecuteChanged;
+        public void Dispose() => _canExecuteSubscription.Dispose();
+
+        public IObservable<object> Observe => Observable.Never<object>();
+    }
 }
diff --git a/MrMeeseeks/Extensions/TExtensions.cs b/MrMeeseeks/Extensions/TExtensions.cs
@@ -22,12 +22,19 @@ public static T AddTo<T>(this T element, ICollection<T> collection)
         }
 
         // ReSharper disable once RedundantAssignment
-        public static T SetTo<T, TSet>(this T element, ref TSet reference) where T : TSet
+        public static T SetTo<T, TSet>(this T element, out TSet reference) where T : TSet
         {
             reference = element;
             return element;
         }
 
+        // ReSharper disable once RedundantAssignment
+        public static T SetTo<T, TSet>(this T element, Action<TSet> setAction) where T : TSet
+        {
+            setAction(element);
+            return element;
+        }
+
         public static IEnumerable<T> ToEnumerable<T>(this T element)
         {
             yield return element;