C# 为什么合并后的可观测序列不以与其组成序列之一相同的方式发出信号？

请参阅下面的两个单元测试（

ReactiveObject

来自）。唯一的区别是第一个单元测试监视一个合并的序列，第二个单元测试监视一个正在合并的序列。第一个单元测试失败，而第二个单元测试通过

更新：具体来说，第一个单元测试在最后一次断言时失败，因为命中率为零而不是1。第二个单元测试成功

为什么第一次单元测试失败

[TestFixture]
public class ReactiveListTests : ReactiveObject
{
    private bool _showAll;

    private IReactiveDerivedList<Node> _nodes;

    public bool ShowAll
    {
        get { return _showAll; }
        set { this.RaiseAndSetIfChanged(ref _showAll, value); }
    }

    public class Node : ReactiveObject
    {
        private bool _isSelected;
        public bool IsSelected
        {
            get { return _isSelected; }
            set { this.RaiseAndSetIfChanged(ref _isSelected, value); }
        }

        private bool _isHidden;
        public bool IsHidden
        {
            get { return _isHidden; }
            set { this.RaiseAndSetIfChanged(ref _isHidden, value); }
        }

        public ReactiveList<Node> Nodes { get; private set; }

        public Node()
        {
            Nodes = new ReactiveList<Node>(scheduler: Scheduler.Immediate) { ChangeTrackingEnabled = true };
        }
    }


    [Test]
    public void WhenInnerReactiveListItemIsChanged_ThenObservableShouldBeSignaled()
    {
        var inner = new[] { new Node() { Nodes = { new Node() } } };
        var nodes = new ReactiveList<Node>(inner, scheduler: Scheduler.Immediate);

        // set up combined signal
        var nodeChanged = nodes.Select(node => node.Nodes.ItemChanged).Merge().Select(_ =>
            {
                return Unit.Default;
            });
        var showAllToggled = this.WhenAnyValue(vm => vm.ShowAll).Select(_ => 
            {
                return Unit.Default;
            });
        var signal = nodeChanged.Merge(showAllToggled);

        _nodes = nodes.CreateDerivedCollection(node => node,
                                               node => ShowAll || node.Nodes.Any(innerNode => !innerNode.IsHidden),
                                               null,
                                               signal);

        // whenever inner node item changes, increment
        int hitCount = 0;
        signal.Subscribe(_ =>
            {
                hitCount++;
            });

        Assert.AreEqual(0, hitCount);

        _nodes[0].Nodes[0].IsSelected = true;

        Assert.AreEqual(1, hitCount);
    }


    [Test]
    public void WhenInnerReactiveListItemIsChanged_ThenObservableShouldBeSignaled2()
    {
        var inner = new[] { new Node() { Nodes = { new Node() } } };
        var nodes = new ReactiveList<Node>(inner, scheduler: Scheduler.Immediate);

        // set up combined signal
        var nodeChanged = nodes.Select(node => node.Nodes.ItemChanged).Merge().Select(_ =>
            {
                return Unit.Default;
            });
        var showAllToggled = this.WhenAnyValue(vm => vm.ShowAll).Select(_ => 
            {
                return Unit.Default;
            });
        var signal = nodeChanged.Merge(showAllToggled);

        _nodes = nodes.CreateDerivedCollection(node => node,
                                               node => ShowAll || node.Nodes.Any(innerNode => !innerNode.IsHidden),
                                               null,
                                               signal);

        // whenever inner node item changes, increment
        int hitCount = 0;
        nodeChanged.Subscribe(_ =>
            {
                hitCount++;
            });

        Assert.AreEqual(0, hitCount);

        _nodes[0].Nodes[0].IsSelected = true;

        Assert.AreEqual(1, hitCount);
    }

[TestFixture]
公共类ReactiveListTests:ReactiveObject
{
私人布卢·肖瓦尔；
私有IReactiveDerivedList_节点；
公共布尔ShowAll
{
获取{return\u showAll；}
设置{this.RaiseAndSetIfChanged（ref _showAll，value）；}
}
公共类节点：反应对象
{
私立学校当选；
公选学校
{
获取{return}isSelected；}
设置{this.RaiseAndSetIfChanged（ref isSelected，value）；}
}
私人住宅；
公共图书馆
{
获取{return\u ishiden；}
设置{this.RaiseAndSetIfChanged（ref_ishiden，value）；}
}
公共反应列表节点{get；private set；}
公共节点（）
{
节点=新的反应列表（调度器：scheduler.Immediate）{ChangeTrackingEnabled=true}；
}
}
[测试]
当NerReactiveListItems被更改时公共无效\u然后Observables应被签名（）
{
var inner=new[]{new Node（）{Nodes={new Node（）}}}；
var节点=新的反应列表（内部，调度程序：scheduler.Immediate）；
//设置组合信号机
var nodeChanged=nodes.Select（node=>node.nodes.ItemChanged）.Merge（）.Select（\u=>
{
返回单位。默认值；
});
var showAllToggled=this.whenyValue（vm=>vm.ShowAll）。选择（\u=>
{
返回单位。默认值；
});
var信号=nodeChanged.Merge（showAllToggled）；
_节点=节点。CreateDerivedCollection（节点=>node，
node=>ShowAll | | node.Nodes.Any（innerNode=>！innerNode.ishiden），
无效的
信号）；
//每当内部节点项发生更改时，递增
整数命中率=0；
信号。订阅（=>
{
命中率++；
});
Assert.AreEqual（0，命中率）；
_节点[0]。节点[0]。IsSelected=true；
断言.AreEqual（1，命中率）；
}
[测试]
当NerReactiveListItems被更改时公共无效\u然后Observables应被签名2（）
{
var inner=new[]{new Node（）{Nodes={new Node（）}}}；
var节点=新的反应列表（内部，调度程序：scheduler.Immediate）；
//设置组合信号机
var nodeChanged=nodes.Select（node=>node.nodes.ItemChanged）.Merge（）.Select（\u=>
{
返回单位。默认值；
});
var showAllToggled=this.whenyValue（vm=>vm.ShowAll）。选择（\u=>
{
返回单位。默认值；
});
var信号=nodeChanged.Merge（showAllToggled）；
_节点=节点。CreateDerivedCollection（节点=>node，
node=>ShowAll | | node.Nodes.Any（innerNode=>！innerNode.ishiden），
无效的
信号）；
//每当内部节点项发生更改时，递增
整数命中率=0；
nodeChanged.Subscribe（=>
{
命中率++；
});
Assert.AreEqual（0，命中率）；
_节点[0]。节点[0]。IsSelected=true；
断言.AreEqual（1，命中率）；
}