feat: Add sorting support

Author: DerekGooding

SimpleDataGrid/Controls/PageDataGrid.cs

@@ -25,6 +25,15 @@ public IPagedCollection? PagedSource
         set => SetValue(PagedSourceProperty, value);
     }
 
+    /// <summary>
+    /// Initializes a new instance of the <see cref="PagedDataGrid"/> class.
+    /// </summary>
+    public PagedDataGrid()
+    {
+        Sorting += OnSorting;
+    }
+
+
     private static void OnPagedSourceChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
     {
         if (d is PagedDataGrid grid && e.NewValue is IPagedCollection paged)
@@ -39,6 +48,13 @@ private static void OnPagedSourceChanged(DependencyObject d, DependencyPropertyC
             };
         }
     }
+
+    /// <summary>
+    /// Handles the <see cref="DataGrid.Sorting"/> event.
+    /// </summary>
+    /// <param name="sender">The sender of the event.</param>
+    /// <param name="e">The event data.</param>
+    protected virtual void OnSorting(object sender, DataGridSortingEventArgs e) { }
 }
 
 /// <summary>
@@ -55,4 +71,32 @@ public class PagedDataGrid<T> : PagedDataGrid
         get => (PagedCollection<T>?)base.PagedSource;
         set => base.PagedSource = value;
     }
+
+    /// <summary>
+    /// Handles the <see cref="DataGrid.Sorting"/> event.
+    /// </summary>
+    /// <param name="sender">The sender of the event.</param>
+    /// <param name="e">The event data.</param>
+    protected override void OnSorting(object sender, DataGridSortingEventArgs e)
+    {
+        if (PagedSource == null) return;
+
+        var direction = e.Column.SortDirection == System.ComponentModel.ListSortDirection.Ascending
+            ? System.ComponentModel.ListSortDirection.Descending
+            : System.ComponentModel.ListSortDirection.Ascending;
+
+        e.Column.SortDirection = direction;
+
+        var propertyName = e.Column.SortMemberPath;
+        if (string.IsNullOrEmpty(propertyName)) return;
+
+        var parameter = System.Linq.Expressions.Expression.Parameter(typeof(T), "x");
+        var property = System.Linq.Expressions.Expression.Property(parameter, propertyName);
+        var lambda = System.Linq.Expressions.Expression.Lambda<Func<T, object>>(System.Linq.Expressions.Expression.Convert(property, typeof(object)), parameter);
+
+        PagedSource.SetSort(lambda.Compile(), direction == System.ComponentModel.ListSortDirection.Ascending);
+
+        e.Handled = true;
+    }
+
 }

SimpleDataGrid/Pagination/PagedCollection.cs

@@ -16,10 +16,21 @@ public class PagedCollection<T> : IPagedCollection, INotifyPropertyChanged
     private IReadOnlyList<T> _filtered = [];
 
     private readonly List<Func<T, bool>> _filters = [];
+    private readonly List<(Func<T, object> selector, bool ascending)> _sorts = [];
     private Func<T, string>? _searchSelector;
     private string? _searchTerm;
     private bool _useWildcards;
 
+    /// <summary>
+    /// Gets a value indicating whether the collection is sorted.
+    /// </summary>
+    public bool IsSorted => _sorts.Count > 0;
+
+    /// <summary>
+    /// Occurs when the sorting changes.
+    /// </summary>
+    public event EventHandler? SortChanged;
+
     /// <summary>
     /// Initializes a new instance of the <see cref="PagedCollection{T}"/> class.
     /// </summary>
@@ -73,6 +84,30 @@ public void SetSearch(Func<T, string> selector, string? term, bool useWildcards
         ApplyFiltering();
     }
 
+    /// <summary>
+    /// Sets the sort criteria for the collection.
+    /// </summary>
+    /// <typeparam name="TKey">The type of the key to sort by.</typeparam>
+    /// <param name="selector">A function to extract the key for sorting.</param>
+    /// <param name="ascending">A value indicating whether to sort in ascending order.</param>
+    public void SetSort<TKey>(Func<T, TKey> selector, bool ascending)
+    {
+        _sorts.Clear();
+        _sorts.Add((x => selector(x)!, ascending));
+        ApplyFiltering();
+        SortChanged?.Invoke(this, EventArgs.Empty);
+    }
+
+    /// <summary>
+    /// Clears the sort criteria from the collection.
+    /// </summary>
+    public void ClearSort()
+    {
+        _sorts.Clear();
+        ApplyFiltering();
+        SortChanged?.Invoke(this, EventArgs.Empty);
+    }
+
     private void ApplyFiltering()
     {
         IEnumerable<T> query = _source;
@@ -97,6 +132,23 @@ private void ApplyFiltering()
             }
         }
 
+        if (_sorts.Count > 0)
+        {
+            IOrderedEnumerable<T>? orderedQuery = null;
+            foreach (var (selector, ascending) in _sorts)
+            {
+                if (orderedQuery == null)
+                {
+                    orderedQuery = ascending ? query.OrderBy(selector) : query.OrderByDescending(selector);
+                }
+                else
+                {
+                    orderedQuery = ascending ? orderedQuery.ThenBy(selector) : orderedQuery.ThenByDescending(selector);
+                }
+            }
+            query = orderedQuery ?? query;
+        }
+
         _filtered = [.. query];
         _currentPage = 0;
         RaiseAllChanged();