Question

I was working on a proof of concept for binding to an ObservableCollection property which returns the result of a delegate. The delegate has a property set up for it also, so that I can change the expression used, and it triggers OnPropertyChanged for the Collection. This allows me to bind a ComboBox to the Collection, and upon changing the expression/query the available choices in the ComboBox will change too.

Code:

public delegate List<string> Del();

private Del _query;
public Del Query
{
    get
    {
        return _query;
    }
    set
    {
        _query= value;
        OnPropertyChanged("BindList");
    }
}

private ObservableCollection<string> bindList;
public ObservableCollection<string> BindList
{
    get
    {
        var results = Query();
        bindList = new ObservableCollection<string>(results);
        return bindList;
    }
    set
    {//I believe I need this setter for the extra functionality provided by ObservableCollections over Lists
        if(bindList != value) {
            bindList = value;
            OnPropertyChanged("BindList");
        }
    }
}

Since this works, I’m wanting to make a class out of it that will be simple to bind to. I’m asking for guidance on how to do so. I’ve thought some about subclassing ObservableCollection, but was having issues with how to set the Items. I’ve also considered just a custom class using interfaces like IEnumerable and ICollectionView (along with the notification Interfaces).

So in summary, how would you build a class to incorporate a collection whose members are based on a delegate query (LINQ to be specific) with regard to subclassing/interfaces?

Thanks in advance.

Answer 1

Here’s what I’ve come up with so far. Hasn’t had a lot of testing yet, but so far its looking pretty good.

public class DynamicCollection<T> : IEnumerable, INotifyCollectionChanged
{
    public ICollectionView Collection { get; private set; }

    public delegate List<T> Del();

    private Del query;
    public Del Query
    {
        get
        {
            return query;
        }
        set
        {
            if (query != value)
            {
                query = value;//set the new query
                T currentItem = (T)Collection.CurrentItem;//save current item
                Collection = new PagedCollectionView(Query());//recreate collection with new query
                Collection.MoveCurrentTo(currentItem);//move current to the previous current (if it doesn't exist, nothing is selected)
                OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));//Notify colleciton has changed.
            }
        }
    }

    public DynamicCollection()
    {
        Collection = new PagedCollectionView(new List<T>());//empty collection
    }

    public DynamicCollection(IEnumerable<T>collection)
    {
        Collection = new PagedCollectionView(collection);
    }

    public DynamicCollection(Del delegateQuery)
    {
        Query = delegateQuery;
    }

    #region IEnumerable Members
    public IEnumerator GetEnumerator()
    {
        return Collection.GetEnumerator();
    }
    #endregion IEnumerable Members

    #region INotifyCollectionChanged Members
    public event NotifyCollectionChangedEventHandler CollectionChanged;
    protected void OnCollectionChanged(NotifyCollectionChangedEventArgs e)
    {
        NotifyCollectionChangedEventHandler handler = CollectionChanged;
        if (handler != null)
        {
            CollectionChanged(this, e);
        }
    }
    #endregion INotifyCollectionChanged Members
}

It can be bound to in a ComboBox using ItemsSource="{Binding Path=myCollection, Mode=TwoWay}" (given you have DyamicCollection myCollection set up as a property in your ViewModel/data context).

It all works by setting the Query, which in my case I give a LINQ to XML query that returns a List. The Collection updates on this, and the bound ComboBox reflects this update.

Please feel free to critique this. I’m fairly certain I’ve got something off, or maybe there is even a better way to do this. I’m open to feedback, and will update this answer as it evolves.