Использование ReactiveCommand и WhenAny в унаследованных классах

Я бы создал функцию регистрации в своем базовом классе для регистрации наблюдаемых с помощью CombineLatest.

    property IObservable<bool> CanDo;

    public IObservable<bool> RegisterCanDo( IObservable<bool> toRegister ){
            if ( CanDo == null ){
                    CanDo = toRegister;
            }else{
                    Cando = CanDo.CombineLatest(toRegister, (a,b) => a && b);
            }

    }

Итак, теперь, когда у вас есть наблюдаемый объект, который вы хотите сделать частью своей цепочки CanDo, вы просто добавляете его с помощью RegisterCanDo.

    public class B : A
    {
        public int Prop2 { get {...} set {...} }

        public B()
        {
            //Senseless code. For explanation only
            IObservable<bool> canDeleteExecute = this.WhenAny(vm => vm.Prop1, vm => vm.Prop2, (p1, p2) => CanDoSomething());
            RegisterCanDo(canDeleteExecute);
        }
    }

Это именно то, что вы хотели выше. Однако будьте осторожны с резьбой. Я не сделал его потокобезопасным для добавления и удаления источников сообщений при объединении значений.

Вы можете добавлять и удалять источники сообщений для объекта Концентратора, и вы можете наблюдать за Концентратором на предмет истинного значения.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Reactive.Disposables;
using System.Reactive.Subjects;

public class BoolObservableConcentrator : IObservable<bool>
{
    private readonly Dictionary<IObservable<bool>, bool> dict = new Dictionary<IObservable<bool>, bool>();

    public IDisposable Register(IObservable<bool> observable)
    {
        dict.Add(observable, false);
        var d = observable.Subscribe(value =>
        {
            dict[observable] = value;
            Fire();
        });
        return Disposable.Create(() =>
        {
            d.Dispose();
            dict.Remove(observable);
            Fire();
        });
    }

    private readonly Subject<bool> subject = new Subject<bool>();

    private void Fire()
    {
        subject.OnNext(dict.Values.All(x => x));
    }

    public IDisposable Subscribe(IObserver<bool> observer)
    {
        return subject.Subscribe(observer);
    }
}

И протестируйте его:

using System;
using System.Reactive.Subjects;
using Microsoft.VisualStudio.TestTools.UnitTesting;

[TestClass]
public class UnitTest
{
    [TestMethod]
    public void TestMethod1()
    {
        var s0 = new BehaviorSubject<bool>(false);
        var s1 = new BehaviorSubject<bool>(false);

        bool l = false;

        var c = new BoolObservableConcetrator();

        var r0 = c.RegisterSource(s0);
        var r1 = c.RegisterSource(s1);

        var s = c.Subscribe(v => l = v);

        Assert.AreEqual(false, l);

        s0.OnNext(true);
        Assert.AreEqual(false, l);

        s1.OnNext(true);
        Assert.AreEqual(true, l);

        s0.OnNext(false);
        Assert.AreEqual(false, l);

        // Removing one of the message sources should update the result
        r0.Dispose();
        Assert.AreEqual(true, l);
    }
}

Я написал класс расширения для WhenAny. Это гораздо больше, чтобы сделать его похожим на WhenAny в ReactiveUI, но сейчас мне достаточно. Во-первых, посмотрите на использование:

public class A : ReactiveObject
{
    public A()
    {
        //Using almost like WhenAny from ReactiveUI
        CanExecuteObservable = this.WhenAny(() => AProp, CanExecute);
        Command = new ReactiveCommand(CanExecuteObservable);
        Command.Subscribe(x => Execute());
    }

    protected CanExecuteObservable CanExecuteObservable { get; private set; }
    public ReactiveCommand Command { get; private set; }

    protected virtual bool CanExecute()
    {
        return AProp > 10;
    }

    private int aProp = 10;
    public int AProp { get { return aProp; } set { this.RaiseAndSetIfChanged(x => x.AProp, value); } }
}

public class B : A
{
    public B()
    {
        //Add one more property dependency for CanExecute
        CanExecuteObservable.AddProperties(() => BProp);
    }

    private int bProp = 10;
    public int BProp { get { return bProp; } set { this.RaiseAndSetIfChanged(x => x.BProp, value); } }

    protected override bool CanExecute()
    {
        return base.CanExecute() && BProp > 100;
    }
}

Реализация:

public static class WhenAnyExtensions
{
    public static CanExecuteObservable WhenAny(this IReactiveNotifyPropertyChanged obj,
        IEnumerable<Expression<Func<object>>> expressions, Func<bool> func)
    {
        return new CanExecuteObservable(obj, expressions, func);
    }

    public static CanExecuteObservable WhenAny(this IReactiveNotifyPropertyChanged obj, Expression<Func<object>> property1, Func<bool> func)
    {
        return obj.WhenAny(new[] { property1 }, func);
    }

    public static CanExecuteObservable WhenAny(this IReactiveNotifyPropertyChanged obj, Expression<Func<object>> property1, Expression<Func<object>> property2, Func<bool> func)
    {
        return obj.WhenAny(new[] { property1, property2 }, func);
    }

    //etc...
}

public class CanExecuteObservable : IObservable<bool>
{
    internal CanExecuteObservable(IReactiveNotifyPropertyChanged obj,
        IEnumerable<Expression<Func<object>>> expressions, Func<bool> func)
    {
        this.func = func;
        AddProperties(expressions);
        obj
            .Changed
            .Where(oc => propertyNames.Any(propertyName => propertyName == oc.PropertyName))
            .Subscribe(oc => Fire());
    }

    private readonly List<string> propertyNames = new List<string>();
    private readonly Func<bool> func;

    public void AddProperties(IEnumerable<Expression<Func<object>>> expressions)
    {
        foreach (var expression in expressions)
        {
            string propertyName = ReflectionHelper.GetPropertyNameFromExpression(expression);
            propertyNames.Add(propertyName);
        }
    }

    public void AddProperties(Expression<Func<object>> property1) { AddProperties(new[] { property1 }); }
    public void AddProperties(Expression<Func<object>> property1, Expression<Func<object>> property2) { AddProperties(new[] { property1, property2 }); }
    //etc...

    public void Clear()
    {
        propertyNames.Clear();
    }

    private readonly Subject<bool> subject = new Subject<bool>();

    private void Fire()
    {
        subject.OnNext(func());
    }

    public IDisposable Subscribe(IObserver<bool> observer)
    {
        return subject.Subscribe(observer);
    }
}

И неинтересный в этом контексте вспомогательный класс для получения имени свойства из выражения:

public class ReflectionHelper
{
    public static string GetPropertyNameFromExpression<T>(Expression<Func<T>> property) 
    {
        var lambda = (LambdaExpression)property;
        MemberExpression memberExpression;

        if (lambda.Body is UnaryExpression) 
        {
            var unaryExpression = (UnaryExpression)lambda.Body;
            memberExpression = (MemberExpression)unaryExpression.Operand;
        } 
        else 
        {
            memberExpression = (MemberExpression)lambda.Body;
        }
        return memberExpression.Member.Name;
    }
}

Почему бы просто не заменить его в производном конструкторе:

Обновление: это версия, учитывающая оригинал.

public class A
{
    public ReactiveCommand SomeCommand { get; protected set; }

    public A()
    {
        SomeCommand = new ReactiveCommand(this.WhenAny(x => x.SomeProp, ...));
    }
}


public class B : A
{
    public A()
    {
        var newWhenAny = this.WhenAny(x => x.SomeOtherProp, ...);

        var canExecute = SomeCommand == null ?
            newWhenAny :
            SomeCommand.CanExecuteObservable.CombineLatest(newWhenAny,(oldCommand, whenAny) => oldCommand && whenAny);

        SomeCommand = new ReactiveCommand(canExecute);
    }
}