Thanks for this & other handy Silverlight posts – I have another addition to my morning tech-related-RSS addiction :-)

If you wrap your source with a ListCollectionView, since IBindingList support IList, you should be able to sort it. In this case, sorting will not be delegated to the IBindingList – it will be performed the same way it would if the collection didn’t implement IBindingList.

If the bug hasn’t been fixed and implementing ITypedList didn’t help, you may want to open a WPF bug on this issue. This will bump up the priority of the internal bug.

Bea

I’m not sure that I understand your question. When you bind to an ObservableCollection, a collection view is created, and your UI ends up really binding to the view instead. Sorting happens at the view level only.

Not sure if this is what you mean, but if you select an item and then sort the collection, the item you selected earlier remains selected. To be clear, if you select item A in index 0, and then sort the collection so that item A is now in index 3, item A (in index 3) is selected. This is by design – WPF tracks items based on their actual identity and not based on index.

Bea

I have several thoughts related to the problem you describe:

- You mention that BindingListCollectionView doesn’t support sorting, but that is not correct. IBindingList supports sorting by specifying a property name and a direction, and BindingListCollectionView delegates sorting to the underlying collection. However, it doesn’t support custom sorting, which I’m assuming is your scenario.

- You ask why ListCollectionView doesn’t delegate AddNew to the underlying collection. ListCollectionView is optimized to work with collections that implement IList, not collections that implement IBindingList. BindingListCollectionView, as expected, delegates AddNew to the underlying IBindingList collection.

- The limitation of not being able to add a new item when the source has no default constructor is very well understood by the team. WPF 4.0 Beta 2 has a new feature that brings us a step closer to having a solution: the introduction of IEditableCollectionViewAddNewItem containing the AddNewItem method. You can read the MSDN documentation about this feature. The sample in MSDN shows how to use it when creating your own custom UI to add a new item (using a ListBox to display the data and a dialog box to enter the new item). From what I can tell, DataGrid doesn’t yet use this method though (although it’s a bit hard to be 100% sure because Reflector doesn’t decompile 4.0 Beta 2 bits).

- Your solution looks great.

Bea

There is nothing in WPF that makes that especially easy – you will need to write your own custom logic.
If you want to allow it to be cancelled, you may need to create a copy of the view and sort that instead. This way, if the user cancels, you still have the original order.

Bea

This is my first comment on your blog! First, I would like to thank you for the very nice posts.

Now to views… I was really frustrated that the BindingList support in WPF was incomplete even in the latest beta (.NET 4). I have the following scenario: suppose I have business objects Mother and Child. There is no default constructor for Child, since each instance must be initialized with a Mother. Mother has a BindingList collection of its children.

Eventually I have Mother as the DataContext of some window and the child collection will be used as source in a CollectionViewSource which in turn is used as the ItemsSource of a DataGrid in that window.

The default behavior of WPF is to create a BindingListCollectionView for the children. However, this does not allow me to sort the items (and I don’t want to write a tedious solution for sorting…). Forcing the view to be of type ListCollectionView does allow sorting, but now the “AddNew” functionality of the DataGrid, which relies on the view, does not work (because ListCollectionView does not know how to create a new instance of Child—it does not have a default constructor).

I came with a prototype solution as follows. The collection of children must inherit from BindingList and override the “RemoveItem” method so that it can raise the ListChanged event with a parameter of type DeleteListChangedEventArgs.
public class DeleteListChangedEventArgs : ListChangedEventArgs
{
public DeleteListChangedEventArgs(object item) : base(ListChangedType.ItemDeleted, -1)
{
Item = item;
}

public object Item { get; set; }
}

With this we have the actual deleted item on the notification of list changes of our BindingList.

Here is the code for my CollectionView implementation:

class MyBindingListCollectionView : ListCollectionView, IEditableCollectionView
{
public IBindingList MySourceCollection { get; private set; }

private bool SuspendNotification;

public Type ItemType { get; private set; }

public MyBindingListCollectionView(IBindingList list)
: base(CopyBindingList(list))
{
ItemType = ItemTypeFromList(list);
MySourceCollection = list;
MySourceCollection.ListChanged += new ListChangedEventHandler(MySourceCollection_ListChanged);
}

protected static Type ItemTypeFromList(object source)
{
Type srcT = source.GetType().GetInterfaces().First(i => i.Name.StartsWith(“IList”));
return srcT.GetGenericArguments().First();
}

///
///
/// Given a source that implements IList, construct an
/// ObservableCollection with a copy of the source.
///
///
protected static IList CopyBindingList(IBindingList source)
{
Type desT = typeof(ObservableCollection).MakeGenericType(ItemTypeFromList(source));
IList lst = Activator.CreateInstance(desT) as IList;
foreach (object o in source)
{
lst.Add(o);
}
return lst;
}

protected override void OnCollectionChanged(System.Collections.Specialized.NotifyCollectionChangedEventArgs args)
{
base.OnCollectionChanged(args);
if (SuspendNotification) return; // ignore changes
SuspendNotification = true;
try
{
switch (args.Action)
{
case System.Collections.Specialized.NotifyCollectionChangedAction.Add:
foreach (object o in args.NewItems)
{
if (o.GetType().Equals(ItemType))
{
MySourceCollection.Add(o);
}
}
break;
case System.Collections.Specialized.NotifyCollectionChangedAction.Remove:
foreach (object o in args.OldItems)
{
MySourceCollection.Remove(o);
}
break;
case System.Collections.Specialized.NotifyCollectionChangedAction.Reset:
// what do we do in this case?
break;
}
}
finally
{
SuspendNotification = false;
}
}

void MySourceCollection_ListChanged(object sender, ListChangedEventArgs e)
{
if (SuspendNotification) return; // ignore changes
SuspendNotification = true;
IList src = SourceCollection as IList;
try
{
switch (e.ListChangedType)
{
case ListChangedType.ItemAdded:
src.Add(MySourceCollection[e.NewIndex]);
break;
case ListChangedType.ItemDeleted:
DeleteListChangedEventArgs ex = e as DeleteListChangedEventArgs;
if (ex != null)
{
src.Remove(ex.Item);
}
break;
case ListChangedType.Reset:
src.Clear();
foreach (object o in MySourceCollection)
{
src.Add(o);
}
break;
}
}
finally
{
SuspendNotification = false;
}
}

object m_New = null;
object IEditableCollectionView.AddNew()
{
m_New = MySourceCollection.AddNew();
return m_New;
}

bool IEditableCollectionView.CanAddNew
{
get { return CurrentAddItem == null && CurrentEditItem == null; }
}

object IEditableCollectionView.CurrentAddItem
{
get { return m_New; }
}

bool IEditableCollectionView.IsAddingNew
{
get { return m_New != null; }
}

void IEditableCollectionView.CancelNew()
{
MySourceCollection.Remove(m_New);
m_New = null;
}

void IEditableCollectionView.CommitNew()
{
m_New = null;
}
}

As you may have noted, I tried to implement only the methods of IEditableCollectionView that are strictly necessary for the AddNew functionality. Since I am forwarding the “AddNew” to the BindingList, objects of type Child are created when necessary. I tested (very briefly) this code with a DataGrid and I didn’t have any problems.

It surely isn’t a very elegant solution, but it is a lot less work than to build a CollectionView from nothing. My question is: why didn’t the designers of ListCollectionView used the IBindingList contract to provide AddNew functionality when the SourceCollection implements it?

Thanks,

Domingos.

You can do that with custom sorting, as I show in this post. An even easier way of doing that would be to simply add several sort descriptions to the view. You could even do that all in XAML, by using a CollectionViewSource.

Thanks,
Bea

I know this is an old thread but, im facing a problem with the CollectionView…. It goes as follows:

I have an ObservableCollection(of MyClass) and I use the example from the MSDN Library to do the column sorting….

The problem Im having is that after I sort the Collection View the original index is lost at the CollectionView to the ObservableCollection. It messes up the whole code… Is there a way of binding the ObservableCollection and the CollectionView?

Kenneth