Объединение и фильтрация нескольких событий с помощью WhenAnyObservable

Я думаю, что ваш ответ можно упростить.

var itemChangedObs = this.WhenAnyValue(x => x.MyObject.Active);
var isBusyObs = this.WhenAnyValue(x => x.IsBusy);
var listItemChangedObs = this.WhenAnyObservable(x => x.MyObectsList.ItemChanged).Where(x => x.PropertyName == "Active").Select(_ => MyObjectsList.Any(x => x.Active)).StartsWith(false)
var canRunCommand = itemChangedObs.CombineLatest(listItemChangedObs, isBusyObs, (itemActive, listItemActive, isBusy) => (itemActive || listItemActive) && !isBusy);

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

CombineLatest() не создает значения до тех пор, пока оба Observable не выдали значение, поэтому listItemChanged имеет StartsWith(false) впереди.

WhenAnyValue() всегда будет по умолчанию выдавать значение по умолчанию (T) в качестве его начального значения, поэтому вам не нужен StartsWith с этими операторами.

Вот еще одна альтернатива, которая позволяет избежать необходимости в MyObjectList.Any(), которая имеет сложность O (n). Это решение немного сложнее, но имеет потенциал для немного большей эффективности. Это то же самое, что и подход Гленна CombineLatest, за исключением того, как вычисляется его наблюдаемый объект listItemChangedObs. Эта версия поддерживает общее количество активных объектов в списке. Таким образом, он должен делать только +1 или -1 каждый раз, когда запускается ItemChanged. Затем он просто проверяет, больше ли оно 0.

public MyViewModel()
{
    var itemChangedObs = this.WhenAnyValue(x => x.MyObject.Active);
    var isBusyObs = this.WhenAnyValue(x => x.IsBusy);

    // Recalculate the # of active objects each time ObjectList is reassigned.
    var activeListItemCountInitializedObs = this
        .WhenAnyValue(x => x.ObjectList)
        .Select(
            list =>
            {
                // Return 0 if ObjectList is null.
                return list == null ? Observable.Return(0) : list
                    .ToObservable()
                    // Otherwise, increment by 1 for each active object.
                    .Select(x => x.Active ? 1 : 0)
                    // We use Aggregate, which is a single value sequence, because
                    // we're only interested in the final result.
                    .Aggregate((acc, current) => acc + current);
            })
        // We no longer need the inner observable from the last time active item count
        // was initialized. So unsubscribe from that one and subscribe to this most recent one.
        .Switch();

    var activeListItemCountChangedObs = this
        .WhenAnyObservable(x => x.ObjectList.ItemChanged)
        .Where(x => x.PropertyName == "Active")
        // Increment or decrement the number of active objects in the list.
        .Select(x => x.Sender.Active ? 1 : -1);

    // An IObservable<bool> that signals if *any* of objects in the list are active.
    var anyListItemsActiveObs = activeListItemCountInitializedObs
        .Select(
            // Use the initialized count as the starting value for the Scan accumulator.
            initialActiveCount =>
            {
                return activeListItemCountChangedObs
                    .Scan(initialActiveCount, (acc, current) => acc + current)
                    // Return true if one or more items are active.
                    .Select(x => x > 0)
                    .StartWith(initialActiveCount > 0);
            })
        // ObjectList was completely reassigned, so the previous Scan accumulator is
        // no longer valid. So we "reset" it by "switching" to the new one.
        .Switch();

    var canRunCommand = itemChangedObs
        .CombineLatest(
            anyListItemsActiveObs,
            isBusyObs,
            (itemActive, listItemActive, isBusy) => (itemActive || listItemActive) && !isBusy);

    Save = ReactiveCommand.CreateFromObservable(() => Observable.Return(Unit.Default), canRunCommand);
}

А вот модульный тест, который прошел, когда я запустил код. По сути, он проверяет, сколько раз ReactiveCommand изменяет состояние CanExecute, и если оно истинно или ложно, каждый раз, когда изменяется одна из переменных.

[Fact]
public void TestMethod1()
{
    var objectList = new ReactiveList<IMyObject>(
        initialContents: new[] { new MyObject(), new MyObject() },
        resetChangeThreshold: 0.3,
        scheduler: ImmediateScheduler.Instance);

    objectList.ChangeTrackingEnabled = true;

    IMyViewModel myViewModel = new MyViewModel
    {
        ObjectList = objectList,
        MyObject = new MyObject()
    };

    var canExecute = myViewModel.Save
        .CanExecute
        .CreateCollection(scheduler: ImmediateScheduler.Instance);

    Assert.Equal(1, canExecute.Count);
    Assert.False(canExecute[0]);

    myViewModel.ObjectList[0].Active = true;
    Assert.Equal(2, canExecute.Count);
    Assert.True(canExecute[1]);

    myViewModel.MyObject.Active = true;
    Assert.Equal(2, canExecute.Count);

    myViewModel.IsBusy = true;
    Assert.Equal(3, canExecute.Count);
    Assert.False(canExecute[2]);

    myViewModel.IsBusy = false;
    Assert.Equal(4, canExecute.Count);
    Assert.True(canExecute[3]);

    myViewModel.MyObject.Active = false;
    Assert.Equal(4, canExecute.Count);

    var object1 = new MyObject { Active = true };
    var object2 = new MyObject { Active = true };
    myViewModel.ObjectList = new ReactiveList<IMyObject>(
        initialContents: new[] { object1, object2 },
        resetChangeThreshold: 0.3,
        scheduler: ImmediateScheduler.Instance);

    Assert.Equal(4, canExecute.Count);

    object1 = new MyObject { Active = false };
    object2 = new MyObject { Active = false };
    myViewModel.ObjectList = new ReactiveList<IMyObject>(
        initialContents: new[] { object1, object2 },
        resetChangeThreshold: 0.3,
        scheduler: ImmediateScheduler.Instance);

    Assert.Equal(5, canExecute.Count);
    Assert.False(canExecute[4]);
}