filter taking into account value of previous elements: (how) can it be done?

[shimpe]

I'm trying to do something as follows (and I have no idea if this is possible with dynamic data, or how to approach it)
(needless to say I'm pretty much a beginner in dynamic data)

I have a SourceCache that contains a list of objects like the following (contrived example):

new(name: "a", value:"1", isparent:false, valid_if_name:null, valid_if_contains:null),
new(name: "b", value:"2", isparent:true, valid_if_name:null, valid_if_contains:null),
new(name: "c", value:"3", isparent:false, valid_if_name:"b", valid_if_contains: "1"),
new(name: "c", value:"4", isparent:false, valid_if_name:"b", valid_if_contains: "2")

Looking at the above list, the entry with name "c" and value:"3" is not valid, because the entry with name :"b" does not contain value:"1". The entry with name:"c" and value:"4" on the other hand is valid, because the entry with name:"b" contains value "2". The "isparent" flag indicates that another entry down the list depends on this entry's value.

Since the entry with name "b" has value "2", I would like to filter the list so that I keep only

new(name: "a", value:"1", isparent:false, valid_if_name:null, valid_if_contains: null),
new(name: "b", value:"2", isparent:true, valid_if_name:null, valid_if_contains: null),
new(name: "c", value:"4", isparent:false, valid_if_name:"b", valid_if_contains: "2")

I think I need a way to filter the SourceCache while accumulating some state/context information (i.e. record the value of each element marked as isparent:true, so that the filter, when it arrives at item c can lookup in its accumulated context information so far what the value of item "b" was to decide if it entry for item c is valid or not.

These lists are converted into ui controls using some DataTemplate, and the above is an attempt at generating some generic ui which dynamically can display/hide different controls based on the value of some parent control.

(Note: Instead of actually filtering, an alternative could be to add a visible flag into the objects, but in order to correctly manipulate those flags, I again somehow need access to some accumulating state).

Is something like this possible? Or is something completely different needed?

[JakenVeina]

You want .FilterOnObservable(). Something along the lines of...

using var source = new SourceCache<long, Item>()
{
    new Item()
    {
        Id = 1,
        Value = 1
    },
    new Item()
    {
        Id = 2,
        Value = 2
    },
    new Item()
    {
        Id = 3,
        Value = 3,
        ParentId = 2,
        ParentValue = 1
    },
    new Item()
    {
        Id = 4,
        Value = 4,
        ParentId = 2,
        ParentValue 2
    }
};

using var subscription = source
    .Connect()
    .FilterOnObservable(item => (item.ParentId is long parentId)
        ? source
            .Watch(parentId)
            .Select(parentChange => parentChange.Current.Value == item.ParentValue)
        : Observable.Return(true))
    .Subscribe();

If you don't have direct access to the SourceCache<> to use inside the .FilterOnObservable() operator, you can take whatever source you DO have, and call .AsObservableCache() on it, and use the output of that as effectively the same thing.

[shimpe]

Thanks that seems to work. Could one use AutoRefresh or AutoRefreshOnObservable to re-evaluate the filters when an element in the SoureCache is changed? I tried a few things, but seem to be hitting compiler errors (about not being able to infer types) which I find difficult to interpret.

[shimpe]

Part of the solution probably will be to make Item derive from ReactiveObject and call RaiseAndSetIfChanged in the property I want to AutoRefresh on?

[JakenVeina]

So, you're interested in reacting to changes in the parent items, as well?

If possible, the most-effecitve solution is almost always going to be using the immutable items pattern.

var itemToChange = source.Lookup(2).Value;

source.AddOrUpdate(itemToChange with
{
    Value = 1
});

The query I wrote above covers this, because the SourceCache<> will publish a Replace change for this action, and .Watch() will capture that.

If immutable items isn't feasible, I'd say .FilterOnObservable() is probably going to be the better option, as it just has fewer moving parts involved, under the hood, to achieve the same outcome. And yeah, using ReactiveObject items is the most straightforward way to have mutable items...

// Assuming both .ParentId and .Value can change, if it's just .Value, the outer .Switch() is unneccessary
using var subscription = source
    .Connect()
    .FilterOnObservable(item => item
        .WhenPropertyChanged(static item => item.ParentId)
        .Select(parentId => (parentId is long parentIdValue)
            ? source
                .Watch(parentIdValue)
                .Select(parentChange => parentChange.Current
                    .WhenPropertyChanged(static parentItem => parentItem.Value))
                .Switch()
                .Select(parentValue => parentValue == item.ParentValue)
            : Observable.Return(true))
        .Switch())
    .Subscribe();

var itemToChange = source.Lookup(2).Value;

itemToChange.Value = 1;

.AutoRefresh() and .AutoRefreshOnObservable() would also get the job done, and they're arguably less cumbersome on the consumer's end. But they're also likely gonna translate to more work behind the scenes, since Refresh changes will flow to all downstream operators, instead of just affecting only the .FilterOnObservable() operator. Of course, if you have other downstream stuff that depends on the properties that can change, maybe you actually want that.

// Assuming both .ParentId and .Value can change, if it's just .Value, the outer .Switch() is unneccessary
using var subscription = source
    .Connect()
    .AutoRefresh(static item => item.ParentId)
    .FilterOnObservable(item => (item.ParentId is long parentId)
        ? source
            .AutoRefresh(static parentItem => parentItem.Value)
            .Watch(parentId)
            .Select(parentChange => parentChange.Current.Value == item.ParentValue))
        : Observable.Return(true))
    .Subscribe();

var itemToChange = source.Lookup(2).Value;

itemToChange.Value = 1;

[shimpe]

Thanks for all your replies. This covers my immediate need. I have noticed in the past few days I still have a lot to learn... (not just about dynamic data, but about reactive programming in general).