WPF DataGrid Virtualization – Strange error after scrolling

At first, sorry for my bad english, it's a lot of text so i use google translator.

I have found a solution. It's a bit ugly, but in my case it's the only one I found.

The virtualization uses the old list entries when scrolling and inserts them again at the bottom. The DataContext has updated itself according to the new list element, but the texts in the TextBlock have not, but these are used for highlighting. The solution in my case was that I save certain BindingExpressions in the Tag property of the TextBlock and as soon as the next row is loaded while scrolling (event LoadingRow in DataGrid) I reset the BindingExpressions according to the updated DataContext. But this only works if the GUI is already rendered. If the code is executed too early, the BindingExpressions will be null. That's why it's important that LoadingRow is only executed after rendering and after the actual highlighting action.

Here is an overview of the most important changes

Formular9.xaml

• Using MyGrid instead of DataGrid (see the corresponding class for details)
• Specification of virtualization
• New property 'RaiseHighlight'

.

<local:MyGrid
...
local:Highlighter9.RaiseHighlight="{Binding IsFilterReady, Mode=OneWay}"
EnableRowVirtualization="True"
VirtualizingStackPanel.VirtualizationMode="Recycling"/>

Formular9.xaml.cs

• New property 'IsFilterReady', which is set to true after the list is filtered by refresh

.

public string Filter
{
    get => this.filter;
    set
    {
        this.filter = value;
        this.RaisePropertyChanged();

        this.DisplayedItems.Refresh();
        this.IsFilterReady = true;
    }
}

public bool IsFilterReady
{
    get => this.isFilterReady;
    set
    {
        this.isFilterReady = value;
        this.RaisePropertyChanged();
    }
}

MyGrid.cs

Own DataGrid that provides required functionalities

public class MyGrid : DataGrid
{
    public MyGrid()
    {
        this.LoadingRow += GridOnLoadingRow;
    }

    public bool IsHighlightingReady { get; set; }

    public bool IsVirtualization => VirtualizingPanel.GetIsVirtualizing(this) || this.EnableColumnVirtualization || this.EnableRowVirtualization;

    public VirtualizationMode VirtualizationMode => VirtualizingPanel.GetVirtualizationMode(this);

    public string Filter { get; set; }

    private void GridOnLoadingRow(object sender, DataGridRowEventArgs e)
    {
        Highlighter9.GridOnLoadingRow((MyGrid)sender, e);
    }
}

Highlighter9.cs

• New Property 'RaiseHighlight' to start processing
• LoadingRow Event that is only executed when the actual highlighting has been performed
• Determine & set the BindingExpressions

.

public static class Highlighter9
{
    // Fires the start of the highlighting process
    public static readonly DependencyProperty RaiseHighlightProperty = DependencyProperty.RegisterAttached(
        "RaiseHighlight",
        typeof(bool),
        typeof(Highlighter9),
        new PropertyMetadata(false, null, CoerceValueCallback));

    public static void SetRaiseHighlight(DependencyObject obj, bool value)
    {
        obj.SetValue(RaiseHighlightProperty, value);
    }

    public static bool GetRaiseHighlight(DependencyObject obj)
    {
        return (bool)obj.GetValue(RaiseHighlightProperty);
    }

    private static object CoerceValueCallback(DependencyObject d, object baseValue)
    {
        // It is important to wait until the list has been filtered before highlighting.
        // If the list elements are not fully rendered, information that is necessary such as BindingExpression is missing.
        if ((bool)baseValue)
        {
            var filter = GetFilter(d);
            if (filter == null || string.IsNullOrWhiteSpace(filter))
            {
                return baseValue;
            }

            var grid = (MyGrid)d;
            grid.IsHighlightingReady = false;

            Application.Current.Dispatcher.BeginInvoke(DispatcherPriority.Render, new Action(() =>
            {
                DoAction(grid, filter);
            }));
        }

        return baseValue;
    }

    #endregion

    #region Filter Property
    public static readonly DependencyProperty FilterProperty =
        DependencyProperty.RegisterAttached("Filter", typeof(string), typeof(Highlighter9));

    public static void SetFilter(DependencyObject obj, string value)
    {
        obj.SetValue(FilterProperty, value);
    }

    public static string GetFilter(DependencyObject obj)
    {
        return (string)obj?.GetValue(FilterProperty);
    }
    #endregion

    private static void DoAction(MyGrid grid, string filter)
    {
        // Save current filter data to the grid.
        // If there are several grids in the form, complications arise because the grids attract each other's data.
        // Grid also needs the data so that the correct data is known via the LoadingRow event
        grid.Filter = filter;

        var gridRows = grid.GetDescendants<DataGridRow>().ToList();
        foreach (var row in gridRows)
        {
            HighlightRow(row, grid);
        }

        grid.IsHighlightingReady = true;
    }

    private static void HighlightRow(DataGridRow row, MyGrid grid)
    {
        var txtBlocks = row.GetDescendants<TextBlock>().ToList();
        if (!txtBlocks.Any())
        {
            return;
        }

        foreach (var txtBlock in txtBlocks)
        {
            HighlightTextBlock(txtBlock, grid);
        }
    }

    private static void HighlightTextBlock(TextBlock txtBlock, MyGrid grid)
    {
        // Check whether virtualization is activated
        if (grid.IsVirtualization && grid.VirtualizationMode == VirtualizationMode.Recycling)
        {
            // Determine and save property name from binding
            var exp = txtBlock.GetBindingExpression(TextBlock.TextProperty);
            txtBlock.Tag = exp?.ResolvedSourcePropertyName;
        }

        var text = txtBlock.Text;
        if (string.IsNullOrEmpty(text))
        {
            return;
        }

        // Check whether the text contains the filter text
        var index = text.IndexOf(grid.Filter, StringComparison.CurrentCultureIgnoreCase);
        if (index < 0)
        {
            // Filter text not found
            return;
        }

        // Generate Inlines with highlighting information
        var inlines = new List<Inline>();
        while (true)
        {
            // Text from beginning to filter text
            inlines.Add(new Run(text.Substring(0, index)));

            // Text that corresponds to the filter text
            inlines.Add(new Run(text.Substring(index, grid.Filter.Length))
                            {
                                Background = Brushes.Yellow,
                            });

            // Text from filter text to ending
            text = text.Substring(index + grid.Filter.Length);

            // Check whether the remaining text also contains the filter text
            index = text.IndexOf(grid.Filter, StringComparison.CurrentCultureIgnoreCase);
            if (index < 0)
            {
                // If not, add remaining text and exit loop
                inlines.Add(new Run(text));
                break;
            }
        }

        // Replace Inlines
        txtBlock.Inlines.Clear();
        txtBlock.Inlines.AddRange(inlines);
    }
    
    public static void GridOnLoadingRow(MyGrid grid, DataGridRowEventArgs e)
    {
        // When the filter is entered again, the LoadingRow event is executed before the actual processing of the highlighter is carried out.
        // Ignore code execution until the highlighter finishes processing.
        // Otherwise it will lead to the error that BindingExpression information is not available
        if (!grid.IsHighlightingReady)
        {
            return;
        }

        // Leave method if virtualization is deactivated
        if (!grid.IsVirtualization)
        {
            return;
        }

        if (grid.VirtualizationMode == VirtualizationMode.Recycling)
        {
            // Determine text blocks of the row
            if (e.Row.GetDescendants<TextBlock>().Any())
            {
                HighlightRowWithUpdateBinding(e.Row, grid);
            }
            else
            {
                // If no text blocks are found, Row is loaded but not yet rendered. Delay call.
                Application.Current.Dispatcher.BeginInvoke(new Action(() =>
                {
                    if (e.Row.GetDescendants<TextBlock>().Any())
                    {
                        HighlightRowWithUpdateBinding(e.Row, grid);
                    }
                }), DispatcherPriority.Send);
            }
        }
        else
        {
            // Here the row has not yet been rendered, GetDescendants in HighlightRow does not find any text boxes, delay the call
            Application.Current.Dispatcher.BeginInvoke(new Action(() =>
            {
                HighlightRow(e.Row, grid);
            }), DispatcherPriority.Send);
        }
    }

    private static void HighlightRowWithUpdateBinding(DataGridRow row, MyGrid grid)
    {
        // Reset bindings for the text blocks
        foreach (var txtBlock in row.GetDescendants<TextBlock>())
        {
            // Determine property name from binding or tag property
            var exp = txtBlock.GetBindingExpression(TextBlock.TextProperty);
            var path = exp != null ? exp.ResolvedSourcePropertyName : txtBlock.Tag.ToString();

            // Reset binding
            var binding = new Binding { Source = txtBlock.DataContext, Path = new PropertyPath(path) };
            txtBlock.SetBinding(TextBlock.TextProperty, binding);
        }

        HighlightRow(row, grid);
    }
}

MyListItem.cs

• Unchanged, see above