How to Implement DataGrid Sorting in WPF

Overview

The WPF DataGrid control provides built-in column sorting out of the box.
When CanUserSortColumns is set to true (the default), clicking a column header sorts the rows by that column.
Built-in sorting covers the common cases, but real applications frequently need programmatic sorting, custom comparison rules, or a way to reset the grid to its unsorted state.
This article covers the essentials and explores patterns for each of those requirements.

Prerequisites / Environment

• Framework / Language: .NET 6 or later / C# 10
• Target control: WPF DataGrid (System.Windows.Controls)
• Architecture: applicable to both code-behind and MVVM
• Verification environment: .NET 10 / Windows 11

The examples assume the grid is bound to an observable collection of a Product type that exposes Name and Price properties.

The tables in this article were measured in the environment above.
Each caption states how its table was measured.
The following points were confirmed in that environment:

• A DataGridTextColumn without an explicit SortMemberPath picks up the path from its Binding.
• A template column with no Binding ends up with an empty SortMemberPath and cannot be sorted.

Enabling Default Sorting

By default, every column in a DataGrid is sortable as long as its SortMemberPath can be resolved against the bound data source:

<DataGrid ItemsSource="{Binding Products}"
          AutoGenerateColumns="False"
          CanUserSortColumns="True">
  <DataGrid.Columns>
    <DataGridTextColumn Header="Name"  Binding="{Binding Name}"  SortMemberPath="Name" />
    <DataGridTextColumn Header="Price" Binding="{Binding Price}" SortMemberPath="Price" />
  </DataGrid.Columns>
</DataGrid>

Clicking the Name header once sorts ascending, and clicking again reverses to descending.
The default behavior does not return to an unsorted state, so clear logic must be implemented explicitly when needed — see How to Reset DataGrid Sorting in WPF for that pattern.

The table below records what lands in SortMemberPath and CanUserSort for each way of declaring a column.

Measured on .NET 10 / Windows 11, varying only the column declaration. order after a header click is the order after running the same sort that a click on that column’s header runs; the original order is carol, alice, bob.

SortMemberPath is filled in from the Binding path even when it is not written. Stating it in the XAML above makes the intent explicit; omitting it produces the same result.

The last row is the one to note. A DataGridTemplateColumn without a Binding ends up with an empty SortMemberPath, and CanUserSort becomes False as well.
It stays out of sorting even with CanUserSortColumns set to True. Making a template column sortable requires stating SortMemberPath explicitly; the last row, a template column with SortMemberPath="Name", sorted by name.

Sorting via Code-Behind

Sorting can be triggered programmatically by manipulating DataGrid.Items.SortDescriptions:

using System.ComponentModel;

dataGrid.Items.SortDescriptions.Clear();
dataGrid.Items.SortDescriptions.Add(
    new SortDescription(nameof(Product.Price), ListSortDirection.Descending));

The view re-sorts as soon as a SortDescription is added, so no Items.Refresh() call is needed.

Reset the column-header sort glyph too so the UI stays in sync:

foreach (var col in dataGrid.Columns)
    col.SortDirection = null;

var priceCol = dataGrid.Columns.First(c => c.SortMemberPath == nameof(Product.Price));
priceCol.SortDirection = ListSortDirection.Descending;

Without this glyph update the header arrow still points at the previous column, even though the rows are ordered correctly, which makes the sorted state look inconsistent to the user.

Custom Sort Logic with ListCollectionView

For comparison rules that SortDescriptions cannot express — such as an ordinal, culture-independent string comparison (a SortDescription compares strings with culture-aware rules) or sorting by an expression not exposed as a public property — use ListCollectionView.CustomSort. (SortDescriptions can still sort by a public property whose getter computes a value; the limit is comparisons not exposed as a property.) Multi-level sorting does not need it: add several SortDescription entries instead.
CollectionViewSource.GetDefaultView returns an ICollectionView, which does not expose CustomSort. For an in-memory collection the concrete type is ListCollectionView, but a view over another source (such as a DataView) is not, so narrow the type with a pattern match rather than an unconditional cast that could throw InvalidCastException:

if (CollectionViewSource.GetDefaultView(dataGrid.ItemsSource) is ListCollectionView view)
{
    view.CustomSort = Comparer<Product>.Create((a, b) =>
        StringComparer.OrdinalIgnoreCase.Compare(a.Name, b.Name));
}

CustomSort and SortDescriptions do not stack; the one set last replaces the other. Setting CustomSort cleared SortDescriptions, and adding a SortDescription afterward reset CustomSort to null. The reference for ListCollectionView.CustomSort states the first half: setting the property clears SortDescriptions. Switching back to SortDescriptions therefore needs no extra step.

Measured on .NET 10 / Windows 11 on the default view of a three-item collection, and on a DataGrid bound to it for the last row.

Notes

• SortMemberPath is required only when it differs from the column’s Binding path. For a plain DataGridTextColumn bound to a simple property, sorting works without it, but specifying it explicitly avoids surprises when the binding path is complex.
• Items.Refresh() rebuilds the view, but it is not needed after changing SortDescriptions. In the measurement above, a Refresh with a row selected kept both SelectedItem and CurrentCell.
• CustomSort is a property of ListCollectionView, the default view returned for in-memory collections. A view over another source — such as the BindingListCollectionView returned for a DataView — is not a ListCollectionView and offers no CustomSort, which is why the pattern match above skips it. For those sources the ordering must come from another mechanism, such as SortDescriptions or sorting at the data source.
• Sorting changes only the display order, not the underlying collection. Code that iterates the bound collection directly still sees the original order.

Summary

For most line-of-business apps the default mechanism covers the common cases.
Reach for CustomSort only when the data requires special ordering that SortDescription cannot express.

• DataGrid (WPF Standard Control Demo App): measures the order produced by header clicks and why sorting from code fails while a cell is being edited