UI not updated when calling SourceCache.Edit.

[adamradocz]

Hi,

First, I think your library is awesome, I really enjoy using it.
Unfortunately, I have some issues with it.

What a want to achieve is the following:

• Convert the DTO to Model.
• If the Model is new add it to the cache, but if the Model exists update the model and refresh the UI.
• The Model should be deleted from the cache if no update is coming in X time.

When a new Model is added to the cache, it appears on the UI, but the updates are not propagating.
Plus, when the Model expires it is deleted from the UI, but never added back when a new Model arrives.

Thank you very much for your help.

Here's the code:

internal class MainWindowViewModel : ReactiveObject, IDisposable
{
    private readonly SourceCache<Track, int> _tracksCache = new(track => track.Id);
    private readonly IDisposable _cleanup;
    private readonly ReadOnlyObservableCollection<Track> _tracks;
    private bool _disposedValue;

    public ReadOnlyObservableCollection<Track> InboundTracks => _tracks;

    public MainWindowViewModel()
    {
        var config = new MapperConfiguration(cfg => cfg.CreateMap<TrackDto, Track>());
        var mapper = config.CreateMapper();

        var tracksSourceListCleanup = _tracksCache
            .Connect()
            .ExpireAfter(track => GetExpiredTimeInterval(track))
            .Sort(SortExpressionComparer<Track>.Ascending(track => track.Id))
            .ObserveOn(new DispatcherScheduler(Application.Current.Dispatcher))
            .Bind(out _tracks)
            .DisposeMany()
            .Subscribe((_) => Console.WriteLine(_tracksCache.Count));

        var generator = new GeneratorService();
        var generatorCleanup = generator.Tracks
            .Subscribe(trackDtos => _tracksCache.Edit(innerTracks =>
            {
                foreach (var trackDto in trackDtos)
{
                    if (trackDto.Time >= GetFutureToleranceTime() || trackDto.Time <= GetExpiredToleranceTime())
                    {
                        continue;
                    }

                    var track = innerTracks.Lookup(trackDto.Id);
                    if (track.HasValue)
                    {
                        track.Value.Time = trackDto.Time;
                        track.Value.Updates++;

                        //You may also need to do the following [if properties are used for filtering, sorts, grouping etc]
                        innerTracks.Refresh(track.Value);
                    }
                    else
                    {
                        var newTrack = mapper.Map<Track>(trackDto);
                        innerTracks.AddOrUpdate(newTrack);
                    }
                }
            }));

        _cleanup = new CompositeDisposable(tracksSourceListCleanup, generatorCleanup);
    }

    private static DateTime GetFutureToleranceTime() => DateTime.Now + TimeSpan.FromSeconds(2);
    private static DateTime GetExpiredToleranceTime() => DateTime.Now - TimeSpan.FromSeconds(10);
    private static TimeSpan GetExpiredTimeInterval(Track track) => track.Time - (DateTime.Now - TimeSpan.FromSeconds(10));

    #region IDispoable
    protected virtual void Dispose(bool disposing)
    {
        if (!_disposedValue)
        {
            if (disposing)
            {
                _cleanup.Dispose();
            }

            _disposedValue = true;
        }
    }

    public void Dispose()
    {
        // Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
        Dispose(disposing: true);
        GC.SuppressFinalize(this);
    }
    #endregion
}

[adamradocz]

It was a binding issue... :)

[RolandPheasant]

I'm pleased you've solved it