WPF 设置资源字典多线程安全读写方法

在 WPF 中，使用 ResourceDictionary 本身不会受到创建线程同步影响，意味着可以在任意的线程创建 ResourceDictionary 资源字典，然后在任意线程使用。但是此时的读写需要有时间上的差距，否则将会多线程读写不安全。在 ResourceDictionary 有一个 CanBeAccessedAcrossThreads 属性用来决定在进行读写的时候是否加上锁，但这个属性是内部的，需要通过黑科技更改才能用上

依据 WPF 的源代码，可以看到 ResourceDictionary 类继承了 IDictionary 接口，也开放了 Add 和 Clear 和 Contains 等方法，在这些方法的实现里面，都会先判断 CanBeAccessedAcrossThreads 属性的值，然后决定是否加上锁进行安全读写

        public void Add(object key, object value)
        {
            // Seal styles and templates within App and Theme dictionary
            SealValue(value);

            if (CanBeAccessedAcrossThreads)
            {
                lock(((ICollection)this).SyncRoot)
                {
                    AddWithoutLock(key, value);
                }
            }
            else
            {
                AddWithoutLock(key, value);
            }

        }

        /// <summary>
        ///     Removes all elements from the IDictionary.
        /// </summary>
        public void Clear()
        {
            if (CanBeAccessedAcrossThreads)
            {
                lock(((ICollection)this).SyncRoot)
                {
                    ClearWithoutLock();
                }
            }
            else
            {
                ClearWithoutLock();
            }
        }

因此想要进行多线程安全的读写就需要设置 CanBeAccessedAcrossThreads 属性，而这个属性的定义如下

        internal bool CanBeAccessedAcrossThreads
        {
            get { return ReadPrivateFlag(PrivateFlags.CanBeAccessedAcrossThreads); }
            set { WritePrivateFlag(PrivateFlags.CanBeAccessedAcrossThreads, value); }
        }

也就是说这是一个内部的属性，只有 FrameworkTemplate 和 Style 两个类才能给他赋值。而 FrameworkTemplate 是一个抽象类，不过 DataTemplate 继承了 FrameworkTemplate 类，也就是可以通过 DataTemplate 来设置 Resources.CanBeAccessedAcrossThreads 的值

下面写一个辅助类，用于给 ResourceDictionary 设置允许线程安全读写

    public static class ResourceDictionaryCanBeAccessedAcrossThreadsHelper
    {
        public static void SetCanBeAccessedAcrossThreads(ResourceDictionary resourceDictionary)
        {
            _ = new InnerFrameworkTemplate
            {
                // 在 InnerFrameworkTemplate 的 Resources 属性里面
                // 将会设置 Resources.CanBeAccessedAcrossThreads = true 的值
                // 也就是让 Resources 的读写获取都加上锁
                Resources = resourceDictionary
            };
        }

        private class InnerFrameworkTemplate : DataTemplate
        {

        }
    }

大概的使用方法如下

                var resourceDictionary = new ResourceDictionary();
                ResourceDictionaryCanBeAccessedAcrossThreadsHelper
                    .SetCanBeAccessedAcrossThreads(resourceDictionary);

此时通过 VS 的自动变量，可以看到 resourceDictionary 变量的 CanBeAccessedAcrossThreads 是 true 值

测试的代码如下

        public MainWindow()
        {
            InitializeComponent();

            Task.Run(() =>
            {
                var resourceDictionary = new ResourceDictionary();
                ResourceDictionaryCanBeAccessedAcrossThreadsHelper
                    .SetCanBeAccessedAcrossThreads(resourceDictionary);
                resourceDictionary.Add("Foo", "Fx");

                Dispatcher.InvokeAsync(() =>
                {
                    Resources.MergedDictionaries.Add(resourceDictionary);

                    var foo = Resources["Foo"];
                });
            });
        }

当然了，上面的代码即使不加上 SetCanBeAccessedAcrossThreads 也是可以使用的，在设置和读取之间有时间差

设置之后就可以进行多线程开始安全写入，而没有设置之前依然是允许一个线程写一个线程读的。如下面的测试代码，在调用 AddAndGetValue_OnClick 方法的时候，用的不是线程安全的，而调用 AddAndGetValueWithCanBeAccessedAcrossThreads_OnClick 方法加上 CanBeAccessedAcrossThreads 线程安全，对这两个进行多线程读写

        private void AddAndGetValue_OnClick(object sender, RoutedEventArgs e)
        {
            const int count = 10000000;

            var resourceDictionary = new ResourceDictionary();

            Task.Run(() =>
            {
                for (int i = 0; i < count / 2; i++)
                {
                    resourceDictionary.Add(i, i);
                }

                // 加入完成
                Debugger.Break();
            });

            Task.Run(() =>
            {
                for (int i = count / 2 + 1; i < count; i++)
                {
                    resourceDictionary.Add(i, i);
                }

                // 加入完成
                Debugger.Break();
            });

            Task.Run(() =>
            {
                for (int i = count - 1; i >= 0; i--)
                {
                    _ = resourceDictionary[i];
                }
            });
        }

        private void AddAndGetValueWithCanBeAccessedAcrossThreads_OnClick(object sender, RoutedEventArgs e)
        {
            const int count = 10000000;

            var resourceDictionary = new ResourceDictionary();
            ResourceDictionaryCanBeAccessedAcrossThreadsHelper
                .SetCanBeAccessedAcrossThreads(resourceDictionary);

            Task.Run(() =>
            {
                for (int i = 0; i < count / 2; i++)
                {
                    resourceDictionary.Add(i, i);
                }

                // 加入完成
                Debugger.Break();
            });

            Task.Run(() =>
            {
                for (int i = count / 2 + 1; i < count; i++)
                {
                    resourceDictionary.Add(i, i);
                }

                // 加入完成
                Debugger.Break();
            });

            Task.Run(() =>
            {
                for (int i = count - 1; i >= 0; i--)
                {
                    _ = resourceDictionary[i];
                }
            });
        }

执行测试可以看到在 AddAndGetValue_OnClick 方法将会有 Task.Run 无法执行完成。而 AddAndGetValueWithCanBeAccessedAcrossThreads_OnClick 方法将会全部执行完成

本文代码放在github欢迎小伙伴访问

在 WPF 里面挖了一个坑，在 Contains 方法里面没有加上锁，因此在 XAML 内的使用还请小心，也许会存在字典出错

        public bool Contains(object key)
        {
        	// 这里缺少了 if (CanBeAccessedAcrossThreads) 这样的代码

            bool result = _baseDictionary.Contains(key);

            if (result)
            {
                KeyRecord keyRecord = _baseDictionary[key] as KeyRecord;
                if (keyRecord != null && _deferredLocationList.Contains(keyRecord))
                {
                    return false;
                }
            }

            //Search for the value in the Merged Dictionaries
            if (_mergedDictionaries != null)
            {
                for (int i = MergedDictionaries.Count - 1; (i > -1) && !result; i--)
                {
                    // Note that MergedDictionaries collection can also contain null values
                    ResourceDictionary mergedDictionary = MergedDictionaries[i];
                    if (mergedDictionary != null)
                    {
                        result = mergedDictionary.Contains(key);
                    }
                }
            }
            return result;
        }

在 XAML 里面使用 StaticResourceExtension 也就是 {StaticResource xx} 的方法获取的时候，将会调用到 Contains 方法。但是在使用的时候还请放心，因为理论上对字典以及 WPF 的 Hashtable 进行一个线程写一个线程读是不会有异常的。本文提供的方法只是为了通过多线程创建资源字典的方法可以用来提升启动性能

当前整个 WPF 源代码都是开源的，请看 https://github.com/dotnet/wpf/

本文会经常更新，请阅读原文： https://blog.lindexi.com/post/WPF-%E8%AE%BE%E7%BD%AE%E8%B5%84%E6%BA%90%E5%AD%97%E5%85%B8%E5%A4%9A%E7%BA%BF%E7%A8%8B%E5%AE%89%E5%85%A8%E8%AF%BB%E5%86%99%E6%96%B9%E6%B3%95.html ，以避免陈旧错误知识的误导，同时有更好的阅读体验。

如果你想持续阅读我的最新博客，请点击 RSS 订阅，推荐使用RSS Stalker订阅博客，或者收藏我的博客导航

本作品采用知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议进行许可。欢迎转载、使用、重新发布，但务必保留文章署名林德熙（包含链接： https://blog.lindexi.com ），不得用于商业目的，基于本文修改后的作品务必以相同的许可发布。如有任何疑问，请与我联系。