Slow DependencyProperty performance in WinUI

[AlexanderEgorov]

What can we expect from the performance of DependencyProperties in WinUI?
This issue has been raised many times in microsoft-ui-xaml repo: 1633, 2487, 4597

We understand that the entire WinUI platform is built as a set of WinRT components, so every platform operation leads to interop.
But, somehow, the TextBlock.Text property works much faster than others.
What is different about TextBlock.Text, and will you be able to optimize other properties to make them as fast as TextBlock.Text? Is there any chance to improve DependencyProperty performance even higher? Can AOT compilation contribute to better DependencyProperty performance?

The following table lists measurements of getting/setting value of DependencyProperties in comparison to WPF (DependencyPropertyTests.zip):

These are not real benchmark tests, so results are approximate

Test	WPF	WinUI
Get	19 ns	2023 ns
Set	135 ns	4272 ns
Set (DP with property change handler)	139 ns	20431 ns
Set the same value	89 ns	4150 ns
Set TextBlock.Text	253 ns	725 ns
Set Border.Background	248 ns	2412 ns

We have even tried to test DepenedencyProperties in C++, and yes, the performance of setting Border.Background is two times faster – but anyway it’s not enough.

Why this is important

We (at DevExpress) are working on a set of C# components for WinUI. In the latest release, we minimized amount of Dependency Property changes during virtualized scrolling in our Data Grid. This helped us make the initial loading time and scrolling performance much faster:

Test	DevExpress WinUI Data Grid v21.2	DevExpress WinUI Data Grid v21.1	WinUI Community Toolkit Data Grid
Cold Startup	1.01 s	2.49 s	1.44 s
Hot Startup	0.36 s	1.64 s	1.24 s
Vertical Scrolling	53 fps*	33 fps*	14 fps*
Horizontal Scrolling	42 fps*	13 fps*	7 fps*

However, the DevExpress WinUI Data Grid still has slower scrolling speed than its WPF counterpart, even though it has significantly less features. An extreme test with 2000 text cells on screen (34 columns and 59 rows) shows that the DevExpress WPF Data Grid is three times more responsive::

• Vertical Scrolling - DevExpress WinUI Data Grid: 4 fps*
• Vertical Scrolling - DevExpress WPF Data Grid: 12 fps*

These results are for text cells without any formatting (remember, the TextBlock.Text property is faster than others). For cells with different backgrounds, or for example, Check Box cells, the difference is even higher and will be noticeable in regular apps.

Any improvements in DependencyProperty performance can help us (and other UI component developers) create controls that are closer to WinForms and WPF in terms of performance (or even surpass them). This will certainly increase the appeal of WinUI as the primary desktop development platform.

*FPS values in above tests are the number of layout cycles per second during scrolling - measured by the following code in both platforms (WinUI and WPF):

public static async Task<string> VerticalScrollingTest() {
    ... //initializing
    double allFramesTime = 0;
    int framesCount = 0;
    for(int z = 0; z < 20; z++) {
        for(int i = 0; i < 10; i++) {
            var s = Stopwatch.StartNew();
            grid.ScrollDown(80);
            await CompositionTargetHelper.WaitRendering();
            s.Stop();
            allFramesTime += s.Elapsed.TotalSeconds;
            framesCount++;
        }
        for(int i = 0; i < 10; i++) {
            var s = Stopwatch.StartNew();
            grid.ScrollUp(80);
            await CompositionTargetHelper.WaitRendering();
            s.Stop();
            allFramesTime += s.Elapsed.TotalSeconds;
            framesCount++;
        }
    }
    return $"Fps {framesCount / allFramesTime}";
}
class CompositionTargetHelper {
    static CompositionTargetHelper() {
        CompositionTarget.Rendering += OnRendering;
    }
    public static Task WaitRendering() {
        return task?.Task ?? (task = new TaskCompletionSource()).Task;
    }
    static TaskCompletionSource task;
    static void OnRendering(object sender, object e) {
        var t = task;
        task = null;
        t?.SetResult();
    }
}

[andrewleader]

Thank you @AlexanderEgorov for filing this detailed posting! I suggest using microsoft/microsoft-ui-xaml#1633 as the primary tracking issue for this, as this is in the WinUI/XAML ownership realm. I'd suggest adding your comment to there and keeping future discussion on that thread.

Additionally, I'm starting an internal email thread to be sure key folks in the XAML and CsWinRT team have seen your detailed analysis. We're actively working on improving the performance of WinUI 3 and already have several improvements in line for 1.0 and the future, but I'll make sure dependency properties is something we're looking at too! THANK YOU!

[AlexanderEgorov]

Thank you very much Andrew!
I've reposted my comment to the 1633 thread.
We are looking forward to any information.

[hez2010]

Got some new numbers with 1.1-preview2, it's faster but still far away from WPF:

Test	WPF	WinUI
Get	33ns	275ns
Set	102ns	3440ns
Set (with handler)	107ns	11397ns
Set (the same value)	83ns	3334ns
Set TextBlock.Text	199ns	690ns
Set Border.Background	426ns	1621ns