Question

Consider using inheritance with ReactiveUI.
I have base ViewModel class with DoSomethingCommand. ‘CanExecute’ for this command depends on property Prop1

public class A : ReactiveObject
{
    public int Prop1 { get {...} set {...} }
    public ReactiveCommand DoSomethingCommand { get; private set; }

    public A()
    {
        IObservable<bool> canDoSomething = this.WhenAny(vm => vm.Prop1, p1 => CanDoSomething());
        DoSomethingCommand = new ReactiveCommand(canDoSomething);
        DoSomethingCommand.Subscribe(x => DoSomething());
    }

    protected virtual bool CanDoSomething()
    {
        return ...
    }
}

In inherited class the ‘CanExecute’ for this command depends additionally on property Prop2

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());
    }
}

What is the best practice to create command and make ‘CanExecute’ dependent on properties from base and inherited classes?
Of course, I want inherited classes shouldn’t change when ‘CanExecute’ in base class become additionally depend on AnotherProp property.

Answer 1

I’ve written extension class for WhenAny. It’s much more to do for making it like WhenAny in ReactiveUI, but enough for me now. First, look at usage:

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;
    }
}

Implementation:

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);
    }
}

And uninteresting, in this context, helper class for getting property name from expression:

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;
    }
}