Make a CustomCollection allow EditItem (Custom CollectionView?)

Question

I am writing a custom observable collection for some of my needs and I want it to allow EditItem when used within a WPF DataGrid.

(see the code of the collection at the end of the question to avoid polluting the reading of the question)

You will see that I thought of 3 solutions. But I cannot get any of them working for now.

Solution 1

According to this question, if I want my ObservableDictionary to allow EditItem, it has to implement the non-generic IList. But as I am using a IDictionary as backing field to store the elements, it is impossible to properly implement the IList interface (because it is based on ordered index).

Unless someone find a way?

Solution 2

Next idea, instead of letting the system chose the CollectionView implementation, I can force it to use my own, like this:

<CollectionViewSource 
    x:Key="FooesSource" 
    Source="{Binding Fooes}" 
    CollectionViewType="local:MyCollectionView" />

To do so, I tried to override one existing CollectionView, one allowing EditItem, to suit my needs. For example:

class ObservableDictionaryCollectionView : ListCollectionView
{
    public ObservableDictionaryCollectionView(IDictionary dictionary) 
        : base(dictionary.Values)
    {
    }
}

But it does not work because dictionary.Values is a ICollection and ICollection does not implement IList (it is the opposite -_-).

Is there another built-in CollectionView that could suit my needs?

Solution 3

Based on the next idea, I could try to write my own, from scratch, CollectionView. But before doing this, I would like to know:

1. If anyone has a better idea?
2. If it is possible?

May be some dictionary constraints made this impossible? Which interfaces should I implement? (IEditableCollectionView, IEditableCollectionViewAddNewItem, IEditableCollectionView, ICollectionViewLiveShaping, etc)

As promised, here is the code of the collection:

public class ObservableDictionary<TKey, TValue> : IDictionary<TKey, TValue>, IEnumerable<TValue>, INotifyCollectionChanged
{
    #region fields

    private IDictionary<TKey, TValue> _innerDictionary;

    #endregion

    #region properties

    public int Count { get { return _innerDictionary.Count; } }

    public ICollection<TKey> Keys { get { return _innerDictionary.Keys; } }

    public ICollection<TValue> Values { get { return _innerDictionary.Values; } }

    public bool IsReadOnly { get { return false; } }

    #endregion

    #region indexors

    public TValue this[TKey key]
    {
        get { return _innerDictionary[key]; }
        set { this.InternalAdd(new KeyValuePair<TKey, TValue>(key, value)); }
    }

    #endregion

    #region events

    public event NotifyCollectionChangedEventHandler CollectionChanged;

    #endregion

    #region constructors

    public ObservableDictionary()
    {
        _innerDictionary = new Dictionary<TKey, TValue>();
    }

    public ObservableDictionary(int capacity)
    {
        _innerDictionary = new Dictionary<TKey, TValue>(capacity);
    }

    public ObservableDictionary(IEqualityComparer<TKey> comparer)
    {
        _innerDictionary = new Dictionary<TKey, TValue>(comparer);
    }

    public ObservableDictionary(IDictionary<TKey, TValue> dictionary)
    {
        _innerDictionary = new Dictionary<TKey, TValue>(dictionary);
    }

    public ObservableDictionary(int capacity, IEqualityComparer<TKey> comparer)
    {
        _innerDictionary = new Dictionary<TKey, TValue>(capacity, comparer);
    }

    public ObservableDictionary(IDictionary<TKey, TValue> dictionary, IEqualityComparer<TKey> comparer)
    {
        _innerDictionary = new Dictionary<TKey, TValue>(dictionary, comparer);
    }

    #endregion

    #region public methods

    public bool ContainsKey(TKey key)
    {
        return _innerDictionary.ContainsKey(key);
    }

    public bool Contains(KeyValuePair<TKey, TValue> item)
    {
        return _innerDictionary.Contains(item);
    }

    public void Add(TKey key, TValue value)
    {
        this.InternalAdd(new KeyValuePair<TKey, TValue>(key, value));
    }

    public void AddRange(IEnumerable<KeyValuePair<TKey, TValue>> items)
    {
        if (!items.Any())
        {
            return;
        }

        var added = new List<TValue>();
        var removed = new List<TValue>();

        foreach (var item in items)
        {
            TValue value;
            if (_innerDictionary.TryGetValue(item.Key, out value))
            {
                removed.Add(value);
            }

            added.Add(item.Value);
            _innerDictionary[item.Key] = item.Value;
        }

        this.CollectionChanged?.Invoke(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, added, null));

        if (removed.Count > 0)
        {
            this.CollectionChanged?.Invoke(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, null, removed));
        }
    }

    public void Add(KeyValuePair<TKey, TValue> item)
    {
        this.InternalAdd(item);
    }

    public bool TryGetValue(TKey key, out TValue value)
    {
        return _innerDictionary.TryGetValue(key, out value);
    }

    public bool Remove(TKey key)
    {
        return this.InternalRemove(key);
    }

    public bool Remove(KeyValuePair<TKey, TValue> item)
    {
        return this.InternalRemove(item.Key);
    }

    public void Clear()
    {
        _innerDictionary.Clear();
        this.CollectionChanged?.Invoke(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
    }

    public void CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
    {
        _innerDictionary.CopyTo(array, arrayIndex);
    }

    public IEnumerator<TValue> GetEnumerator()
    {
        return Values.GetEnumerator();
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return this.GetEnumerator();
    }

    IEnumerator<KeyValuePair<TKey, TValue>> IEnumerable<KeyValuePair<TKey, TValue>>.GetEnumerator()
    {
        return _innerDictionary.GetEnumerator();
    }

    #endregion

    #region private methods

    /// <summary>
    /// Adds the specified value to the internal dictionary and indicates whether the element has actually been added. Fires the CollectionChanged event accordingly.
    /// </summary>
    /// <param name="key"></param>
    /// <param name="value"></param>
    private void InternalAdd(KeyValuePair<TKey, TValue> item)
    {
        IList added = new TValue[] { item.Value };

        TValue value;
        if (_innerDictionary.TryGetValue(item.Key, out value))
        {
            this.CollectionChanged?.Invoke(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, null, new TValue[] { value }));
        }

        _innerDictionary[item.Key] = item.Value;
        this.CollectionChanged?.Invoke(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, added, null));
    }

    /// <summary>
    /// Remove the specified key from the internal dictionary and indicates whether the element has actually been removed. Fires the CollectionChanged event accordingly.
    /// </summary>
    /// <param name="key"></param>
    /// <param name="value"></param>
    private bool InternalRemove(TKey key)
    {
        TValue value;
        if (_innerDictionary.TryGetValue(key, out value))
        {
            _innerDictionary.Remove(key);
            this.CollectionChanged?.Invoke(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, null, new TValue[] { value }));
        }

        return value != null;
    }

    #endregion
}

Answer 1

You could build an ObservableCollection that implements both Dictionary and List, by doubly storing the inserted data into an internal list and a dictionary. The Dictionary provides the advantages of a dictionary, the List providing the better support for Binding Operations.

Disadvantages include doubling up your memory usage, and hurting your item removal time*

* Inserts** and Accesses have the same efficiency as a regular dictionary, but removal has to find the item in the internal list as well

** I guess inserts can also be more costly on the occasions they require array resizes.