DataGrid loses sorting when ItemsSource is bound to an IObservableCollection

Hello,

When an IObservableCollection bound to an itemsource fires an event, or one of its constituents fires NotifyPropertyChanged, the grid loses its sort description.

Here is a sample of the markup I am using (I make sure the events are fired from the dispatcher thread)

        <ms:DataGrid ItemsSource="{Binding NearQuotes}">
            <ms:DataGrid.Columns>
                <ms:DataGridColumn Header="Dealer"
                                   DisplayMemberBinding="{Binding Value.Quote.Dealer,Mode=OneWay}" />

                <ms:DataGridColumn Header="Price"
                                   SortDirection="Ascending"
                                   DisplayMemberBinding="{Binding Value.Quote.Price,Mode=OneWay}"
                                   />
            </ms:DataGrid.Columns>
        </ms:DataGrid>

Note that the elements are sorted just fine when the grid is first populated, or when the user clicks on the headers, but any subsequent change to a binding will clear the sort. In this example, each item in my IObservableCollection (NearQuotes) has a Value property containing another object. Value fires NotifyPropertyChanged and triggers the binding re-evaluation.

Thanks,

Hello,

Thanks for contacting us about this. Please have a go at setting the ReSortOnCollectionChanged property on the DataGrid control to true and see if that solves the issue. If not, please send us a simple repro project.

-Jason Fauchelle

Hi Jason,

Here is a pared-down repro for this issue:

MainWindow.xaml

<Window x:Class="GridSortingBug.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:ms="http://namespaces.mindscape.co.nz/wpf"
        mc:Ignorable="d"
        Title="MainWindow" Height="350" Width="525">
    <Grid>
        <Grid.RowDefinitions>
            <RowDefinition Height="auto"/>
            <RowDefinition Height="*"/>
        </Grid.RowDefinitions>
        <StackPanel >
            <CheckBox Content="Live updates" IsChecked="{Binding Timer.IsEnabled,Mode=TwoWay}"/>
            <TextBlock 
                        TextWrapping="Wrap" 
                       Text="When updates are disabled, note that you can sort Price and LastUpdated correctly, so the fact that those are complex types / bindings is not an issue. This seems to indicate a bug in the binding refresh logic for complex types"/>
        </StackPanel>
        <ms:DataGrid 
            Grid.Row="1"
            ItemsSource="{Binding Quotes,Mode=OneWay}"
                 ReSortOnCollectionChanged="True"
                 AutoGenerateColumns="False"
                 >
            <ms:DataGrid.Columns>
                <ms:DataGridColumn Header="Ticker" DisplayMemberBinding="{Binding Ticker,Mode=OneWay}"/>
                <ms:DataGridColumn Header="Price"  SortDirection="Descending" DisplayMemberBinding="{Binding Ticking.Price,Mode=OneWay}"/>
                <ms:DataGridColumn Header="LastUpdated" DisplayMemberBinding="{Binding Ticking.Timestamp,Mode=OneWay}"/>
            </ms:DataGrid.Columns>
        </ms:DataGrid>
    </Grid>
</Window>

MainWindow.xaml.cs

using System;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Linq;
using System.Windows;
using System.Windows.Threading;

namespace GridSortingBug
{
    // The row-level object
    public class MktData : INotifyPropertyChanged
    {
        private Ticking _ticking;
        public string Ticker { get; }

        public MktData(string ticker) { Ticker = ticker; }
        public Ticking Ticking
        {
            get { return _ticking; }
            set
            {
                _ticking = value;
                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(null));
            }
        }
        public event PropertyChangedEventHandler PropertyChanged;
    }

    /// <summary>
    ///     Component of a row-level object that changes over time
    /// </summary>
    public class Ticking
    {
        public double Price { get; internal set; }
        public DateTime Timestamp { get; } = DateTime.UtcNow;
    }

    /// <summary>
    ///     ViewModel: collection of rows whose items are mutated in the dispatcher thread
    /// </summary>
    internal class MainWindowViewModel
    {
        public DispatcherTimer Timer { get; }
        public ObservableCollection<MktData> Quotes { get; }

        public MainWindowViewModel()
        {
            var tickers = new[] { "AAPL US Equity", "MSFT US Equity", "F Equity", "ACME US Equity", "DEF Equity" };
            var rnd = new Random();
            Quotes = new ObservableCollection<MktData>(tickers.Select(x => new MktData(x) { Ticking = new Ticking() { Price = rnd.NextDouble() * 200 } }));

            Timer = new DispatcherTimer { Interval = TimeSpan.FromMilliseconds(500) };
            Timer.Tick += (sender, args) =>
            {
                var t = tickers[rnd.Next(tickers.Length - 1)];
                var q = Quotes.First(x => x.Ticker == t);
                q.Ticking = new Ticking { Price = rnd.NextDouble() * 200 };
            };             
        }
    }

    /// <summary>
    ///     Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            DataContext = new MainWindowViewModel();
            InitializeComponent();
        }
    }
}

Hello,

Thanks for the repro code. Previously I was focusing on the case where the collection changes - which is fixed by the ReSortOnCollectionChanged property. Looks like your main issue is on changing a property on an item which I'd missed from your original post. This is functionality we do not plan to add, but fortunately is very easy for you to achieve the result you need.

In the example of your repro, the issue is solved if you add the following code after setting the Ticking property:

Quotes.Move(0, 0);

This is a no-op that triggers the DataGrid to update the sorting. This is possible due to ReSortOnCollectionChanged being set to true.

Sorry this is not something we do for you, but I hope this work around will work for you.

-Jason Fauchelle

Thanks, this works indeed abeit is slightly awkward as I use a lot of binding expressions to define sorting in the view. This now lives in the ViewModel.