Initializing sorted collections from XAML - wpf

Question

I have a SortedObservableCollection class (initially based on this). It does exactly what it promises - it is a generic collection, which implements INotifyCollectionChanged and maintains its elements in sorted order (according to a provided IComparer). The order is only checked upon insertion though - when an item is being inserted, it is inserted into a correct place into the collection.
However I encountered a major issue while trying to initialize the collection from XAML with syntax like this (the Items property is of SortedObservableCollection<MyItem> type, Priority is the sorting key):
<my:SomeElement.Items>
<my:MyItem Priority="0">
<my:MyItem Priority="2">
<my:MyItem Priority="1">
</my:SomeElement.Items>
This should result in collection with items in order 2, 1, 0, but it results in order 1, 2, 0.
It took me quite some time to discover the cause: Collection items are first constructed, then added to the collection and only then are their properties' values assigned.
I couldn't find this behavior documented anywhere and I agree it doesn't really matter usually. But in my case, the Priority property is always of value 0, so the sorting doesn't take occur at all (in fact, the items are inserted in reverse order than they are in XAML). And the, after the sorting has taken place, the Priority is initialized.
Did you encounter this behavior yourself? Why is the XAML implemented like this? How can I work around this issue?
The only solution I can think of is to let the items implement INotifyPropertyChanged and then subscribe to it in the Add method (and then update the order when necessary), but I guess this would bring more trouble than it is worth (performance, memory leaks...).
Thanks for any help!

Answer 1

If you are aiming at a collection which is properly sorted at all times, then you'll need to go for the listening approach. You could make you items support a weak event mechanism to prevent them from holding a strong reference to the collection.
Another approach would be to defer sorting until the collection is "fully constructed". You could for example have a flag isSorted in your collection implementation. Have this flag set to false whenever the collection is modified (for simplicity) and check it before the collection is "read".
Something like this:
public void Add(T item)
{
_innerList.Add(item);
_isSorted = false;
}
and:
public int IndexOf(T item)
{
EnsureSorted();
return _innerList.IndexOf(item);
}
where EnsureSorted could look something like this:
private void EnsureSorted()
{
if (!_isSorted)
{
_innerList.Sort(_comparer);
_isSorted = true;
// TODO: Raise the CollectionChanged event here, specifying
// NotifyCollectionChangedAction.Reset
}
}
This should make your collection appear sorted while still allowing it to be unsorted while populating the list.
Perhaps this would be a feasible workaround?
Update:
I created a simple observable collection with this kind of deferred sorting. I think you might find it helpful, at least it should clearify what I mean.
The idea is to call the EnsureSorted method just before "reading" the collection and to clear the isSorted flag whenever collection is modified.
public class SortedObservableCollection<T> : IList<T>, IList, INotifyCollectionChanged, INotifyPropertyChanged
{
private readonly List<T> _innerList;
private IComparer<T> _comparer;
private bool _isSorted;
public event NotifyCollectionChangedEventHandler CollectionChanged;
public event PropertyChangedEventHandler PropertyChanged;
public SortedObservableCollection()
: this(null)
{
}
public SortedObservableCollection(IComparer<T> comparer)
{
_innerList = new List<T>();
_comparer = comparer ?? Comparer<T>.Default;
}
// Call this before "reading" collection
private void EnsureSorted()
{
if (!_isSorted)
{
_innerList.Sort(_comparer);
_isSorted = true;
}
}
// Call this after modifying the collection
private void NotifyChanged()
{
if (PropertyChanged != null)
{
PropertyChanged(this, new PropertyChangedEventArgs("Count"));
}
if (CollectionChanged != null)
{
CollectionChanged(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
}
_isSorted = false;
}
#region List implementation
public int IndexOf(T item)
{
EnsureSorted();
return _innerList.IndexOf(item);
}
public void Insert(int index, T item)
{
EnsureSorted();
_innerList.Insert(index, item);
NotifyChanged();
}
public void RemoveAt(int index)
{
EnsureSorted();
_innerList.RemoveAt(index);
NotifyChanged();
}
public T this[int index]
{
get
{
EnsureSorted();
return _innerList[index];
}
set
{
EnsureSorted();
_innerList[index] = value;
NotifyChanged();
}
}
public void Add(T item)
{
_innerList.Add(item);
NotifyChanged();
}
public void Clear()
{
_innerList.Clear();
NotifyChanged();
}
public bool Contains(T item)
{
return _innerList.Contains(item);
}
public void CopyTo(T[] array, int arrayIndex)
{
EnsureSorted();
_innerList.CopyTo(array, arrayIndex);
}
public int Count
{
get { return _innerList.Count; }
}
public bool IsReadOnly
{
get { return false; }
}
public bool Remove(T item)
{
if (!_innerList.Remove(item))
{
return false;
}
NotifyChanged();
return true;
}
public IEnumerator<T> GetEnumerator()
{
EnsureSorted();
return _innerList.GetEnumerator();
}
#endregion
// Non-generic implementation omitted for brevity...
}