c# - 継承されたクラスでのReactiveCommandとWhenAnyの使用

Question

ReactiveUIで継承を使用することを検討してください。DoSomethingCommandを使用した基本ViewModelクラスがあります。このコマンドの「CanExecute」はプロパティ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 ...
    }
}

継承されたクラスでは、このコマンドの「CanExecute」はプロパティ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());
    }
}

コマンドを作成し、「CanExecute」を基本クラスと継承クラスのプロパティに依存させるためのベストプラクティスは何ですか？もちろん、基本クラスの「CanExecute」がAnotherPropプロパティにさらに依存するようになったときに、継承されたクラスが変更されないようにする必要があります。

score 1 · Accepted Answer

WhenAnyの拡張クラスを作成しました。ReactiveUIのWhenAnyのようにするためにやるべきことはもっとたくさんありますが、今は十分です。まず、使用法を見てください。

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

score 1 · Accepted Answer

基本クラスに登録関数を作成し、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);
        }
    }

score 1 · Accepted Answer

これはまさにあなたが上で望んでいたことです。ただし、糸脱毛には注意してください。値を組み合わせる際にメッセージソースを追加および削除するためのスレッドセーフにはしていません。

メッセージソースをConcentratorオブジェクトに追加および削除したり、Concentratorで真の値を確認したりできます。

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

score 1 · Accepted Answer

派生コンストラクターでそれを置き換えてみませんか？

アップデート：オリジナルを考慮したバージョンです

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

c# - 継承されたクラスでのReactiveCommandとWhenAnyの使用

4 に答える 4

Related

Reference