INotifyPropertyChanged通过Linq引用它的更新属性

Question

I have a collection of classes contained in a ObservibaleCollection<MyObj> and MyObj implements INotifyPropertyChanged , but I need a property located outside of it that references a property in the collection via linq and creates its own collection to update on both the collection change and any of its content linq bound properties changing.

For sake of argument and simplicity lets say my class MyObj contains a property called IsVisible . I want a property that implements its own INotifyPropertyChanged to get a list of MyObj where IsVisible == true and keep it up to date regardless id the collection of MyObj changes or the IsVisible property does.

Is this possible without attaching to the collection changed event and subsequently just directly attaching to each child MyObj.IsVisible property? Is there a way to get INotify to bubble up through linq?

public class MyObj:INotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged;
    public bool IsVisible
    {
        get { return _IsVisible; }
        protected set { if (value != _IsVisible) { _IsVisible= value; PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("IsVisible")); } }
    }
    private bool _IsVisible;
}

public class Foo
{
    ObservableCollection<MyObj> myObjs = new ObservableCollection<MyObj>();
    ObservableCollection<MyObj> myVisibleObjs {
        get{
            return myObjs.where(o => o.IsVisible);
        }
    }
}

I hope what I'm asking makes sense.

Answer 1

You could make use of Reactive Extensions, but for this specific requirement - maintaining a myVisibleObjs - I would use the dynamic data lib.

Try out the following:

    static void Main(string[] args)
    {
        Foo f = new Foo();

        f.BindToVisibleObjects();

        // add more dummy data
        f.Add(false);
        f.Add(true);

        // There will be 2 visible objects in MyVisibleObjects
        foreach (var d in f.MyVisibleObjects)
        {
            Console.WriteLine(d.IsVisible);
        }
        Console.ReadKey();
    }

    public class Foo
    {
        ObservableCollection<MyObj> myObjs = new ObservableCollection<MyObj>();
        public ReadOnlyObservableCollection<MyObj> MyVisibleObjects;

        public Foo()
        {
            // add some dummy data
            myObjs.Add(new MyObj() { IsVisible = true });
            myObjs.Add(new MyObj() { IsVisible = false });
        }

        public void BindToVisibleObjects()
        {
            myObjs.ToObservableChangeSet()
                .Filter(o => o.IsVisible)
                .Bind(out MyVisibleObjects)
                .DisposeMany()
                .Subscribe();
        }

        public void Add(bool vis)
        {
            myObjs.Add(new MyObj() { IsVisible = vis });
        }
    }

The key here is that we bind the filtered observable changeset to a new collection that will be updated as your myObjs changes.