How to Achieve Sortable and Filterable Composite Collections in WPF with Elegance

WPF (Windows Presentation Foundation) is a powerful tool for building rich desktop applications. However, one common challenge developers face is implementing standard sorting and filtering behavior for views of composite collections. In this blog post, we’ll explore this problem and present an elegant solution that simplifies the process of sorting and filtering different object types combined into a single collection.

Understanding the Problem

When working with CompositeCollections in WPF, developers often encounter limitations with sorting and filtering capabilities. A CompositeCollection consists of two or more object collections of different types that you need to merge into a single sortable and filterable collection. The challenge is to achieve this with minimal manual coding while retaining the built-in sorting and filtering features of WPF.

The Initial Approach

One straightforward method to merge these collections is to create a new object that represents the combined data. Here is an example structure that might be used:

class MyCompositeObject
{
    enum ObjectType;
    DateTime CreatedDate;
    string SomeAttribute;
    myObjectType1 Obj1;
    myObjectType2 Obj2;
}

class MyCompositeObjects : List<MyCompositeObject> { }

In this approach:

• You loop through your original object collections.
• Create instances of MyCompositeObject, which contains core properties that you desire for sorting.
• This method, although effective, can feel a bit clunky—especially with potential maintenance challenges down the line.

The Elegant Solution

Update and Reflection

Upon revisiting the problem, a more refined solution can be implemented that leverages reflection in C#. The key idea is to simplify the composite object while ensuring that WPF’s data binding capabilities remain effective.

Here’s the updated definition of our composite object:

class MyCompositeObject
{
    DateTime CreatedDate;
    string SomeAttribute;
    Object Obj1;  // Changes from specific type to a more general Object type
}

class MyCompositeObjects : List<MyCompositeObject> { }

Benefits of the New Approach

• Simplicity: By using a general Object for Obj1, we allow different types to be stored without specifying them at compile-time.
• Runtime Type Resolution: The actual type that is assigned to Obj1 gets determined at runtime, which allows WPF to dynamically apply the correct data template for display.
• Built-in Features: You still gain access to the inherent sorting and filtering capabilities offered by WPF collections.

Implementation Steps

1. Define your Composite Object: Set up MyCompositeObject using a general Object type for properties that might vary.
2. Populate Your Composite Collection: Loop through your different object collections and populate MyCompositeObjects with MyCompositeObject instances.
3. Bind to UI: Use WPF data binding to connect your composite collection to the UI components, ensuring the correct templates are applied based on the actual type stored in Obj1.

Conclusion

Sorting and filtering composite collections need not be a daunting task in WPF. By embracing reflection and refining our approach to object design, we can create elegant, easy-to-maintain solutions that leverage the powerful capabilities of WPF. This results not only in cleaner code but also a more enjoyable experience for the end user.

As you encounter similar challenges in your WPF applications, remember that a touch of creativity and an appreciation for the tools at your disposal can go a long way!