可观察订阅未触发

Question

我开始研究 Reactive Extensions 以及如何将它们应用于常见场景以启用更易于管理和可读的代码。

我现在正在研究基本概念，并构建了一个简单的类：

public class ValidatableObject<TValue>
{
    public bool IsValid { get; private set; } = true;
    public TValue Value { get; }
    public ICollection<IValidationRule<TValue>> Rules { get; }

    public ValidatableObject(TValue value)
    {
        Value = value;
        Rules = new List<IValidationRule<TValue>>();
        Rules.ToObservable()
             .All(rule => rule.Check(Value))
             .Subscribe(b => IsValid = b);
    }
}

public interface IValidationRule<T>
{
    bool Check(T value);
}

public class FailingValidationRule<T> : IValidationRule<T>
{
    public bool Check(T value) => false;
}

public static void main()
{
    var theObject = new object();
    var v = new ValidatableObject<object>(theObject);

    // v.IsValid should be true

    v.Rules.Add(new FailingValidationRule<object>());

    // v.IsValid should be false
}

对这个类的简单单元测试表明它没有像我期望的那样运行，而且我可能错过了一个基本部分。我期望的是，当我向Rules 添加一个项目时，Rules 中的每个规则都会被评估，并且结果将存储在IsValid 中。但是，在将旨在失败的规则添加到规则集合后，我没有看到 IsValid 被更新为 false。

这也忽略了一个事实，即 Check 方法的评估结果可能会根据 Value 属性的更改而更改。我可以看到 Check 方法可能也需要在这里返回一个 observable 。

为什么在这种情况下 IsValid 不更新，以及设置这种行为的最小实现是什么样的？

Answer 1

该.ToObservable()操作是在那个时间点收集的一次性的快照。未来对集合的任何添加都不会通过 observable。

所以你需要使用一些可以让你观察变化的东西。

给你最直接的并行您目前使用我建议从改变什么ICollection<IValidationRule<TValue>>来System.Collections.ObjectModel.ObservableCollection<IValidationRule<TValue>>。请注意，这不是你应该做的方式，但我想给你一些你可以立即看到的与你的问题中的代码相关的东西。

然后，您可以像这样编写代码：

public class ValidatableObject<TValue>
{
    public bool IsValid { get; private set; } = true;
    public TValue Value { get; }
    public System.Collections.ObjectModel.ObservableCollection<IValidationRule<TValue>> Rules { get; }

    public ValidatableObject(TValue value)
    {
        Value = value;
        Rules = new ObservableCollection<IValidationRule<TValue>>();

        Observable
            .FromEventPattern<
                    System.Collections.Specialized.NotifyCollectionChangedEventHandler,
                    System.Collections.Specialized.NotifyCollectionChangedEventArgs>(
                h => Rules.CollectionChanged += h,
                h => Rules.CollectionChanged -= h)
            .Select(ep => Rules.All(rule => rule.Check(Value)))
            .Subscribe(b => IsValid = b);
    }
}

请注意，我曾经FromEventPattern从CollectionChanged事件中构建可观察对象，但我仍在使用 LINQ to Objects 来评估规则。您在代码中完成此操作的方式只能设置IsValid为true. 我这样做的方式将让它设置为true或false取决于规则。

我创建了几个测试规则：

public class ValidationRuleTrue<T> : IValidationRule<T>
{
    public bool Check(T value) => true;
}

public class ValidationRuleFalse<T> : IValidationRule<T>
{
    public bool Check(T value) => false;
}

然后我运行了这个：

void Main()
{
    var theObject = new object();
    var v = new ValidatableObject<object>(theObject);
    Console.WriteLine(v.IsValid);
    v.Rules.Add(new ValidationRuleTrue<object>());
    Console.WriteLine(v.IsValid);
    v.Rules.Add(new ValidationRuleFalse<object>());
    Console.WriteLine(v.IsValid);
}

我有：

真的
真的
错误的

这是可以预料的。

但是，您的代码结构不适合使用 Rx。您的查询可能很容易被构造为将可观察管道推送到不同的线程。如果发生这种情况，代码将不会产生正确的结果。

举个例子，试试这个简单的改变：

        Observable
            .FromEventPattern<
                    System.Collections.Specialized.NotifyCollectionChangedEventHandler,
                    System.Collections.Specialized.NotifyCollectionChangedEventArgs>(
                h => Rules.CollectionChanged += h,
                h => Rules.CollectionChanged -= h)
            .Select(ep => Rules.All(rule => rule.Check(Value)))
            .ObserveOn(Scheduler.Default)
            .Subscribe(b => IsValid = b);

现在，当我运行相同的测试代码时，我得到了这个：

真的
真的
真的

基本上 finalConsole.WriteLine(v.IsValid);在 observable 在Scheduler.Default更新上运行之前运行IsValid。你有一个竞争条件。

如果您打算开始更多地使用 Rx，您可以轻松地创建一个使用在不同线程上运行的调度程序的查询。所以你需要以一种对 Rx 有意义的方式编写你的类。

像这样尝试：

public class ValidatableObject<TValue>
{
    public IObservable<bool> IsValid { get; private set; }
    public TValue Value { get; }

    public IEnumerable<IValidationRule<TValue>> Rules { get; }
    private ObservableCollection<IValidationRule<TValue>> _rules;

    public IDisposable AddRule(IValidationRule<TValue> rule)
    {
        _rules.Add(rule);
        return Disposable.Create(() => _rules.Remove(rule));
    }

    public ValidatableObject(TValue value)
    {
        Value = value;

        _rules = new ObservableCollection<IValidationRule<TValue>>();

        this.IsValid =
            Observable
                .FromEventPattern<
                        NotifyCollectionChangedEventHandler,
                        NotifyCollectionChangedEventArgs>(
                    h => _rules.CollectionChanged += h,
                    h => _rules.CollectionChanged -= h)
                .Select(ep => _rules.All(rule => rule.Check(Value)))
                .ObserveOn(Scheduler.Default);
    }
}

注意两点。

(1)IsValid现在是IObservable<bool>摆脱了竞争条件的an 。

(2) 规则不是公开ObservableCollection给整个外部世界来操作的，而是有一个单独的AddRule方法来添加规则和IDisposable删除规则。这意味着只有添加规则的代码才能删除它。它得到了更好的控制。您的代码并非 100% 都需要工作 - 您当然可以公开ObservableCollection- 但这是在 Rx 世界中思考操作的好方法。

现在我可以像这样编写我的测试代码：

void Main()
{
    var theObject = new object();
    var v = new ValidatableObject<object>(theObject);

    var subscription = v.IsValid.Subscribe(isValid => Console.WriteLine(isValid));

    var rule1 = v.AddRule(new ValidationRuleTrue<object>());
    var rule2 = v.AddRule(new ValidationRuleFalse<object>());
    rule2.Dispose(); //remove `rule2`
}

我得到了以下预期值：

真的
错误的
真的

这是我查看实现值本身的观察的基本方法：

public interface IValidationRule<T> where T : INotifyPropertyChanged
{
    bool Check(T value);
}

public class ValidatableObject<TValue> where TValue : INotifyPropertyChanged
{
    public IObservable<bool> IsValid { get; private set; }
    public TValue Value { get; }

    public IEnumerable<IValidationRule<TValue>> Rules { get; }
    private ObservableCollection<IValidationRule<TValue>> _rules;

    public IDisposable AddRule(IValidationRule<TValue> rule)
    {
        _rules.Add(rule);
        return Disposable.Create(() => _rules.Remove(rule));
    }

    public ValidatableObject(TValue value)
    {
        Value = value;

        _rules = new ObservableCollection<IValidationRule<TValue>>();

        var rulesChanged = 
            Observable
                .FromEventPattern<
                        NotifyCollectionChangedEventHandler,
                        NotifyCollectionChangedEventArgs>(
                    h => _rules.CollectionChanged += h,
                    h => _rules.CollectionChanged -= h)
                .Select(ep => Unit.Default);

        var valueChanged =
            Observable
                .FromEventPattern<
                        PropertyChangedEventHandler,
                        PropertyChangedEventArgs>(
                    h => value.PropertyChanged += h,
                    h => value.PropertyChanged -= h)
                .Select(ep => Unit.Default);

        this.IsValid =
            Observable
                .Merge(rulesChanged, valueChanged)
                .Select(ep => _rules.All(rule => rule.Check(Value)))
                .ObserveOn(Scheduler.Default);
    }
}