Batching resource dictionary updates

[StefanKoell]

I'm running into an issue where programmatic updates of resources is causing UI lags and freezes. My understanding is that every update to the resource dictionary is 'instant' and notifies all elements that the resources have changed.

In an app, where UI related settings are handled using app level resources this can get quite expensive. In my case, I have multiple resources which are updated if UI options have changed. This means that each and every setting is notifying all elements that the resources have changed.

I'm wondering if the resource dictionary/theme dictionary can be optimized to allow batch changes and only notify once, when all the changes have been made.

[stevemonaco]

As a workaround, you could try copy/pasting ResourceDictionary into your project and try adding batch support that avoids NotifyHostedResourcesChanged until the end. Skip the indexer:

Avalonia/src/Avalonia.Base/Controls/ResourceDictionary.cs

Lines 33 to 45 in b815659

	public object? this[object key]
	{
	get
	{
	TryGetValue(key, out var value);
	return value;
	}
	set
	{
	Inner[key] = value;
	Owner?.NotifyHostedResourcesChanged(ResourcesChangedEventArgs.Empty);
	}
	}

Probably should be part of the built-in API though. I'm not sure if there are any hardcoded bits that are specific to ResourceDictionary as IResourceDictionary and IResourceProvider are things...

[StefanKoell]

I also took your advise and stripped down the dictionary a bit (removing the nested stuff), in case someone else is interested:

using Avalonia.Controls;
using Avalonia.Controls.Templates;
using Avalonia.Styling;

namespace SomeApp;

/// <summary>
/// An indexed dictionary of resources.
/// </summary>
public class OptimizedResourceDictionary : ResourceProvider
{
    private bool _suspendNotifications;
    private object? _lastDeferredItemKey;
    private Dictionary<object, object?>? _inner;

    /// <summary>
    /// Initializes a new instance of the <see cref="ResourceDictionary"/> class.
    /// </summary>
    public OptimizedResourceDictionary() { }

    /// <summary>
    /// Initializes a new instance of the <see cref="ResourceDictionary"/> class.
    /// </summary>
    public OptimizedResourceDictionary(IResourceHost owner) : base(owner) { }

    public int Count => _inner?.Count ?? 0;

    public object? this[object key]
    {
        get
        {
            TryGetValue(key, out var value);
            return value;
        }
        set
        {
            Inner[key] = value;
            NotifyHostedResourcesChanged(Owner);
        }
    }

    public ICollection<object> Keys => (ICollection<object>?)_inner?.Keys ?? Array.Empty<object>();
    public ICollection<object?> Values => (ICollection<object?>?)_inner?.Values ?? Array.Empty<object?>();

    public sealed override bool HasResources => _inner?.Count > 0;

    private Dictionary<object, object?> Inner => _inner ??= [];

    public void Add(object key, object? value)
    {
        Inner.Add(key, value);
        Owner?.NotifyHostedResourcesChanged(ResourcesChangedEventArgs.Empty);
    }

    public void Clear()
    {
        if (!(_inner?.Count > 0)) 
            return;
        _inner.Clear();
        Owner?.NotifyHostedResourcesChanged(ResourcesChangedEventArgs.Empty);
    }

    public bool Remove(object key)
    {
        if (_inner?.Remove(key) != true) 
            return false;
        Owner?.NotifyHostedResourcesChanged(ResourcesChangedEventArgs.Empty);
        return true;
    }

    public sealed override bool TryGetResource(object key, ThemeVariant? theme, out object? value)
    {
        if (TryGetValue(key, out value))
            return true;

        value = null;
        return false;
    }

    public bool TryGetValue(object key, out object? value)
    {
        if (_inner is not null && _inner.TryGetValue(key, out value))
        {
            if (value is not IDeferredContent deferred) 
                return true;
                
            // Avoid simple reentrancy, which could commonly occur on redefining the resource.
            if (_lastDeferredItemKey == key)
            {
                value = null;
                return false;
            }

            try
            {
                _lastDeferredItemKey = key;
                value = deferred.Build(null) switch
                {
                    ITemplateResult t => t.Result,
                    { } v => v,
                    _ => null,
                };
            }
            finally
            {
                _lastDeferredItemKey = null;
            }

            return true;
        }

        value = null;
        return false;
    }

    public void SetValues(IEnumerable<KeyValuePair<object, object?>> values)
    {
        _suspendNotifications = true;
        try
        {
            foreach (var value in values)
                Inner[value.Key] = value.Value;
        }
        finally
        {
            _suspendNotifications = false;
            NotifyHostedResourcesChanged(Owner);
        }
    }

    /// <summary>
    /// Ensures that the resource dictionary can hold up to <paramref name="capacity"/> entries without
    /// any further expansion of its backing storage.
    /// </summary>
    /// <remarks>This method may have no effect when targeting .NET Standard 2.0.</remarks>
    public void EnsureCapacity(int capacity)
    {
        if (_inner is null)
        {
            _inner = new(capacity);
            return;
        }

#if !NETSTANDARD2_0
        Inner.EnsureCapacity(capacity);
#endif
    }

    public IEnumerator<KeyValuePair<object, object?>> GetEnumerator()
    {
        return _inner?.GetEnumerator() ?? Enumerable.Empty<KeyValuePair<object, object?>>().GetEnumerator();
    }

    protected sealed override void OnAddOwner(IResourceHost owner)
    {
        var hasResources = _inner?.Count > 0;
        if (hasResources)
            owner.NotifyHostedResourcesChanged(ResourcesChangedEventArgs.Empty);
    }

    protected sealed override void OnRemoveOwner(IResourceHost owner)
    {
        var hasResources = _inner?.Count > 0;
        if (hasResources)
            owner.NotifyHostedResourcesChanged(ResourcesChangedEventArgs.Empty);
    }

    private void NotifyHostedResourcesChanged(IResourceHost? owner)
    {
        if (_suspendNotifications)
            return;
        owner?.NotifyHostedResourcesChanged(ResourcesChangedEventArgs.Empty);            
    }
}

If you want me to file a PR to support SetValues on the built-in dictionary, let me know. I'm happy to submit one for that.

[maxkatz6]

This method looks like AddRange.
See https://learn.microsoft.com/en-us/dotnet/api/system.collections.immutable.immutabledictionary-2.addrange?view=net-9.0 for an example.

Makes sense to be defined on AvaloniaDictionary and be supported by the resource dictionary, yes.

[StefanKoell]

I can call the method AddRange but according to the link you posted, the behavior is different when keys already exist (throws an exception). The name may also be misleading because internally the indexer is used. So values are not only added but also updated in case they already exist. If I'm not mistaken there's an AddOrUpdateRange method in the entity framework and may be better fitting.

[stevemonaco]

AddOrUpdateRange sounds good and the functionality makes sense to me to be included by standard. Bridges the gap where you need to update resources, but swapping an entire theme dictionary is not an option.

[StefanKoell]

PR has been filed:
#18354