ReactiveUI 6 with listview not updating - wpf

Question

Been tinkering with reactiveui and trying to get a simple example working in a universal app and having some diffs.
I have viewmodel as:
public class Rooms : ReactiveObject
{
private RoomsService roomService;
private IReactiveCommand<IList<Room>> fetchRooms;
private ObservableAsPropertyHelper<IList<Room>> myRooms;
public IList<Room> MyRooms
{
get { return myRooms.Value; }
}
public Rooms(RoomsService roomsService)
{
this.RoomService = roomsService;
fetchRooms = ReactiveCommand.CreateAsyncTask<IList<Room>>(Observable.Return<bool>(true), async x => await RoomService.Rooms);
fetchRooms.Subscribe(_ => LogMessage("Cool, it was invoked!"));
fetchRooms.ToProperty(this, x => x.MyRooms, out myRooms);
}
public RoomsService RoomService
{
get { return roomService; }
set { roomService = value; }
}
}
and the service that is ticking getting info is:
public class RoomsService
{
private FakeRoomService service = new FakeRoomService();
public IObservable<IList<Room>> Rooms
{
get
{
LogMessage("RoomsService - Rooms property called.");
return Observable
.Interval(TimeSpan.FromSeconds(1))
.Select(_ => service.GetRoomsForUser());
}
}
}
with a basic code behind:
public sealed partial class HubPage : Page
{
private NavigationHelper navigationHelper;
private Rooms rooms = new Rooms(new RoomsService());
/// <summary>
/// Gets the NavigationHelper used to aid in navigation and process lifetime management.
/// </summary>
public NavigationHelper NavigationHelper
{
get { return this.navigationHelper; }
}
/// <summary>
/// Gets the rooms view model.
/// </summary>
public Rooms Rooms
{
get { return this.rooms; }
}
public HubPage()
{
this.InitializeComponent();
this.navigationHelper = new NavigationHelper(this);
this.navigationHelper.LoadState += this.NavigationHelper_LoadState;
}
and the final xaml:
<Page
x:Name="pageRoot"
x:Class="HubPage"
DataContext="{Binding Rooms, RelativeSource={RelativeSource Self}}"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:local="using:Hub"
xmlns:data="using:Hub.Data"
xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
mc:Ignorable="d">
<Grid Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">
<Hub SectionHeaderClick="Hub_SectionHeaderClick">
<HubSection Width="500" x:Uid="Section1Header" Header="Section 1">
<DataTemplate>
<Grid>
<Grid.RowDefinitions>
<RowDefinition Height="300" />
</Grid.RowDefinitions>
<ListView Name="RoomListView" Grid.Row="1" ItemsSource="{Binding MyRooms}">
<ListView.ItemTemplate>
<DataTemplate>
<TextBlock Text="{Binding Name}" FontWeight="Bold" />
</DataTemplate>
</ListView.ItemTemplate>
</ListView>
</Grid>
</DataTemplate>
</HubSection>
</Hub>
</Grid>
I'm clearly missing something obvious in the viewmodel, but I'm not sure what it is. The task seems to tick over but the the property never gets updated... or if it does, its not propagating through to the view?
Any advice or is there a really simple working example for v6 anywhere?

Answer 1

If you await an Observable, it's roughly equivalent to in Rx:
someObservable.TakeLast(1).Publish(new AsyncSubject<T>()).Subscribe();
Here's the problem though, check out your Observable:
return Observable
.Interval(TimeSpan.FromSeconds(1))
.Select(_ => service.GetRoomsForUser());
It never terminates, so TakeLast never returns!
Wat Do?
Instead, we should just write:
fetchRooms = ReactiveCommand.CreateAsyncTask<IList<Room>>(_ => Task.Run(service.GetRoomsForUser());
Then in the View code-behind, we can rig up the timer to invoke the command:
Observable.Interval(TimeSpan.FromSeconds(5), RxApp.MainThreadScheduler)
.InvokeCommand(this, x => x.ViewModel.FetchRooms);
Why the View code-behind?
Setting up timers and invoking commands that Do Stuff in the ViewModel constructor makes it hard to test, because you have to deploy 3032x mocks to stop a bunch of stuff from happening.
Instead, the View constructor should reach into the VM to kick off these actions, and the VM tests can invoke them when they want to explicitly test them.