Regarding recreating/reloading snapshot collections

[AliveDevil]

So … I'm wondering whether this is the "optimal" way (or in general considered as the regular way of solving this).

I have a ViewModel which includes a ReactiveCommand returning a IEnumerable<T>, which is subscribed to in the WhenActivated-event for ReactiveUI (as in d(ViewModel.LoadCommand.Execute().Subscribe());).

Data comes from a EFCore DbContextFactory which is dependency injected into the ViewModel.

The LoadCommand is implemented as I'd say is just normal:

SourceList<ChallengeViewModel> challenges = new();
LoadCommand = ReactiveCommand.CreateFromTask<IEnumerable<Challenge>>(async () =>
{
    challenges.Clear();
    using AppDbContext context = contextFactory.CreateDbContext();
    return await context.Challenges.ToListAsync();
});

Without clearing the SourceList navigating out of the View and navigating back into it duplicates all entries.

Now to get my Model-class into a ViewModel I perform a ToObservableChangeSet-conversion, with

LoadCommand.ToObservableChangeSet()
    .Transform(x => challengeViewModelFactory.Create(x, this))
    .PopulateInto(challenges);

Now there is PopulateInto, but somehow this doesn't look that appealing to me (as in: I'd rather have an Observable which automatically resets itself when a new List comes in). Using BindTo(out BindingList) doesn't work, as Clearing that will result in ArgumentOutOfRange exceptions, and ReadOnlyObservableCollection cannot be cleared.

Getting the SourceList<ChallengeViewModel> into my view this is done per

challenges.Connect()
    .Sort(SortExpressionComparer<ChallengeViewModel>.Descending(x => x.Created))
    .Bind(Challenges)
    .Subscribe();
// ...
public BindingList<ChallengeViewModel> Challenges { get; } = new();

Using a ReadOnlyObservableCollection is kinda inconvenient here, as it requires setting up a field which is then forwarded through a auto-init readonly property.

Is there an easy way of getting a auto-reset IObservable<IChangeSet<>> for on-demand loaded IEnumerables? Ideally without requiring fields (I can assign a read-only property, or bind to a BindingList or similar) or temporary variables (as the SourceList above).
The data flow should look like Command creates a new list everytime it is executed, that list is turned into a transformed ViewModel, sorted and bound to some output property, without using that intermediate SourceList.

For reference this is the complete code:

public class MainViewModel : ReactiveObject
{
    public MainViewModel(IChallengeViewModelFactory challengeViewModelFactory, IDbContextFactory<AppDbContext> contextFactory)
    {
        SourceList<ChallengeViewModel> challenges = new();
        LoadCommand = ReactiveCommand.CreateFromTask<IEnumerable<Challenge>>(async () =>
        {
            challenges.Clear();
            using AppDbContext context = contextFactory.CreateDbContext();
            return await context.Challenges.ToListAsync();
        });
        LoadCommand.ToObservableChangeSet()
            .Transform(x => challengeViewModelFactory.Create(x, this))
            .PopulateInto(challenges);
        challenges.Connect()
            .Sort(SortExpressionComparer<ChallengeViewModel>.Descending(x => x.Created))
            .Bind(Challenges)
            .Subscribe();
    }

    public BindingList<ChallengeViewModel> Challenges { get; } = new();

    public ReactiveCommand<Unit, IEnumerable<Challenge>> LoadCommand { get; }
}

// Update:
I just checked something. With the SourceList as a resettable buffer PopulateInto wouldn't work well (as it's throwing exceptions left and right after being cleared).
Here is the ArgumentException for this specific case: System.ArgumentException.txt