Detection of circular references in RxUI - reactiveui

Question

I set up 2 checkboxes that negate eachother.
The behaviour that I thought to see was an infintite loop (checkbox 1 checks 2 check 1 checks 2...)
Instead the propagation of change is stopped after the other other checkbox is checked by RxUI.
Is there some kind of detected of circular references build into RxUI?
using ReactiveUI;
using ReactiveUI.Fody.Helpers;
using System;
namespace rxnested
{
public class VM01 : ReactiveObject
{
[Reactive]
public bool Prop1 { get; set; }
[Reactive]
public bool Prop2 { get; set; }
public VM01()
{
this.WhenAnyValue(x => x.Prop1)
.Subscribe(x => Prop2 = !x);
this.WhenAnyValue(x => x.Prop2)
.Subscribe(x => Prop1 = !x);
}
}
}
<Window x:Class="rxnested.MainWindow"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
xmlns:local="clr-namespace:rxnested"
mc:Ignorable="d"
Title="MainWindow"
Height="350"
Width="525">
<Window.DataContext>
<local:VM01></local:VM01>
</Window.DataContext>
<StackPanel>
<CheckBox IsChecked="{Binding Prop1}"></CheckBox>
<CheckBox IsChecked="{Binding Prop2}"></CheckBox>
</StackPanel>
</Window>

Answer 1

I think that your expectation that your code should result in infinite loop is wrong.
There are 2 scenarios. Let's consider them separately.
1) Let's say that initially both properties have the same value (let's say it is false). Changing P1 to true will trigger first subscription, which will try setting up P2 into the reverse of the current value of P1 (reverse of true == false). That means that it will try to set false to something that was already false, and thus nothing will happen (that's what [Reactive] give you - before setting the property, it checks if it has changed).
2) Now P1 initially is true, and P2 is false. Changing P1 to false triggers first subscription, which is setting P2 into (!P1), which is in this case true. So, P2 changes from false to true. That triggers second subscription, which tries setting P1 into (!P2), which is in now false. But P1 is already false, so the property does not change (and thus the NotifyPropertyChanged does not fire).
So, the cycle is broken by not setting property blindly, but first checking if it changed at all (to avoid unnecessary NotifyPropertyChanged events).
This is even more clear when you realize that [Reactive] translates into:
private bool _prop2;
public bool Prop2
{
get { return _prop2; }
set { this.RaiseAndSetIfChanged(ref _prop2, value); }
}
Note the name - RaiseAndSetIfChanged.
Now, if you want to see an infinite loop.. simply change your code into this:
public VM01()
{
this.WhenAnyValue(x => x.Prop1)
.Subscribe(x => Prop2 = !Prop2);
this.WhenAnyValue(x => x.Prop2)
.Subscribe(x => Prop1 = !Prop1);
}
This gives me StackOverflowException.