AutoRefresh doesn't work in this situation?

[kurtyoder]

Could be I don't understand how this is supposed to work...

I have a cache:

private readonly SourceCache<OrderAddonReactiveModel, int> _addonsSource = new(x => x.AddonID);

I have a ReadonlyObservableCollection:
private readonly ReadOnlyObservableCollection<OrderAddonReactiveModel> _doors;

I have a massive filter: (The predicate is just watching a few other properties and running a select on this filter)

private Func<OrderAddonReactiveModel, bool> AddonFilter(int sidingMaterialId, int roofStyleId, int roofMaterialId, int sizeId) => addon =>
    {
        if (addon.Active == false) return false;

        if (addon.Parent != null && addon.Parent?.Qty == 0) return false;
        
        bool good = IsAddonQualified(addon.Qualifiers, sidingMaterialId, roofStyleId, roofMaterialId, sizeId);

        if (!good && addon.Qty != 0)
            addon.Qty = 0;

        return good;
    };

And finally I have the binding of the source cache to the observable list

 _addonsSource
            .Connect()
            .AutoRefresh(x=>x.Qty)
            .Filter(x => x.Type == "Door")
            .Filter(addonFilterPredicate)
            .Filter(doorSearchPredicate)
            .SortBy(x => x.DisplayName)
            .Bind(out _doors)
            .DisposeMany()
            .Subscribe();

What I expected to happen is that filters gets rerun when any model's qty changes, which would filter out any models whose parent model's have a qty of zero. This doesn't happen, in fact, nothing seems to happen when the qty gets changed.

Also, how bad is this? Am I on the right track with Dynamic Data or is this making your eyes bleed?

[kurtyoder]

Of course I immediately get it working! I'll leave this post here in case someone is facing a similar situation. Still very curious as to thoughts on implementation.

Added a new filter:

 public Func<OrderAddonReactiveModel, bool> AddonParentFilter() => addon =>
    {
        bool good = (addon.Parent?.Qty ?? 1) != 0;

        if (!good && addon.Qty != 0)
            addon.Qty = 0;
        return good;
    };

Updated the binding

_addonsSource
          .Connect()
          .Filter(x => x.Type == "Door")
          .AutoRefresh(x => x.Parent.Qty)
          .Filter(AddonParentFilter())
          .Filter(addonFilterPredicate)
          .Filter(doorSearchPredicate)
          .SortBy(x => x.DisplayName)
          .Bind(out _doors)
          .DisposeMany()
          .Subscribe();

If I understand correctly, the problem was two-fold. First, Because addonFilter was behind a predicate watching several properties, it wouldn't get run even if the qty of the model changed. Second, I wasn't watching the parent qty, just the qty. Still not entirely sure what difference this would have made as technically the parent qty is just another model's qty. However, I think this is more efficient as it will only trigger for parent's and not every addon change.

[RolandPheasant]

Implementation wise this is fine but loses some efficiency by creating multiple filters. You could make use of the CombineLastest operator to observe multiple properties at once. In this instance AutoRefresh is no longer needed

var prop1Changed = this.WhenValueChanged(x => x.Prop1);
var prop2Changed = this.WhenValueChanged(x => x.Prop2);
var prop3Changed = this.WhenValueChanged(x => x.Prop3);

 var dynamicFilter = prop1Changed.CombineLatest(prop2Changed , prop3Changed,  (prop1, prop2, prop3 ) =>
      {
          //return predicate based on multiple prop values
      }  );

source.Connect()
.Filter(dynamicFilter) 

To make it perfectly efficient you should apply a throttle to the filter to reduce the number of times the filter is applied.

source.Connect()
.Filter(dynamicFilter.Throttle(TimeSpan.FromMilliseconds(250)) 

[kurtyoder]

Thank you! I will try this approach