WPF MVVM模式下如何让屏幕阅读器播报新增ListBox项

针对你在.NET 8 WPF MVVM应用中遇到的屏幕阅读器无法播报ObservableCollection新增项的问题，以下是几种符合MVVM原则的解决方案：

方案1：使用附加行为（推荐，完全解耦ViewModel与视图自动化逻辑） #

这种方式将屏幕阅读器的自动化事件触发逻辑封装在视图层的附加行为中，ViewModel无需做任何修改，完全符合MVVM的关注点分离原则。

步骤1：创建附加行为类 #

using System.Collections.Specialized;
using System.Windows;
using System.Windows.Automation.Peers;
using System.Windows.Automation.Provider;
using System.Windows.Controls;
using System.Windows.Media;

namespace WpfAppAccessibilityTest
{
    public static class ListBoxLiveRegionBehavior
    {
        public static readonly DependencyProperty EnableLiveRegionUpdatesProperty =
            DependencyProperty.RegisterAttached(
                "EnableLiveRegionUpdates",
                typeof(bool),
                typeof(ListBoxLiveRegionBehavior),
                new PropertyMetadata(false, OnEnableLiveRegionUpdatesChanged));

        public static bool GetEnableLiveRegionUpdates(DependencyObject obj)
        {
            return (bool)obj.GetValue(EnableLiveRegionUpdatesProperty);
        }

        public static void SetEnableLiveRegionUpdates(DependencyObject obj, bool value)
        {
            obj.SetValue(EnableLiveRegionUpdatesProperty, value);
        }

        private static void OnEnableLiveRegionUpdatesChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            if (d is ListBox listBox)
            {
                if ((bool)e.NewValue)
                {
                    SubscribeToCollectionChanges(listBox);
                }
                else
                {
                    UnsubscribeFromCollectionChanges(listBox);
                }
            }
        }

        private static void SubscribeToCollectionChanges(ListBox listBox)
        {
            if (listBox.ItemsSource is INotifyCollectionChanged collection)
            {
                collection.CollectionChanged += OnCollectionChanged;
                listBox.SetValue(CollectionProperty, collection);
            }
        }

        private static void UnsubscribeFromCollectionChanges(ListBox listBox)
        {
            if (listBox.GetValue(CollectionProperty) is INotifyCollectionChanged collection)
            {
                collection.CollectionChanged -= OnCollectionChanged;
                listBox.ClearValue(CollectionProperty);
            }
        }

        private static readonly DependencyProperty CollectionProperty =
            DependencyProperty.RegisterAttached(
                "Collection",
                typeof(INotifyCollectionChanged),
                typeof(ListBoxLiveRegionBehavior));

        private static void OnCollectionChanged(object? sender, NotifyCollectionChangedEventArgs e)
        {
            if (e.Action == NotifyCollectionChangedAction.Add && sender is INotifyCollectionChanged collection)
            {
                var listBox = FindListBoxForCollection(collection);
                if (listBox != null)
                {
                    TriggerLiveRegionChanged(listBox);
                }
            }
        }

        private static ListBox? FindListBoxForCollection(INotifyCollectionChanged collection)
        {
            foreach (var window in Application.Current.Windows)
            {
                if (window is Window w)
                {
                    var listBox = FindListBoxInVisualTree(w, collection);
                    if (listBox != null)
                    {
                        return listBox;
                    }
                }
            }
            return null;
        }

        private static ListBox? FindListBoxInVisualTree(DependencyObject parent, INotifyCollectionChanged targetCollection)
        {
            int childrenCount = VisualTreeHelper.GetChildrenCount(parent);
            for (int i = 0; i < childrenCount; i++)
            {
                var child = VisualTreeHelper.GetChild(parent, i);
                if (child is ListBox listBox && listBox.ItemsSource == targetCollection)
                {
                    return listBox;
                }
                var result = FindListBoxInVisualTree(child, targetCollection);
                if (result != null)
                {
                    return result;
                }
            }
            return null;
        }

        private static void TriggerLiveRegionChanged(ListBox listBox)
        {
            if (AutomationPeer.ListenerExists(AutomationEvents.LiveRegionChanged))
            {
                var peer = FrameworkElementAutomationPeer.FromElement(listBox) ??
                           FrameworkElementAutomationPeer.CreatePeerForElement(listBox);
                peer?.RaiseAutomationEvent(AutomationEvents.LiveRegionChanged);
            }
        }
    }
}

步骤2：在XAML中启用附加行为 #

给ListBox添加附加属性，启用自动更新LiveRegion的功能：

<ListBox AutomationProperties.LiveSetting="Assertive" 
         AutomationProperties.Name="My list of things" 
         ItemsSource="{Binding ListOfStuff}"
         local:ListBoxLiveRegionBehavior.EnableLiveRegionUpdates="True"/>

方案2：ViewModel通过事件通知视图触发自动化事件 #

如果项目规模较小，可以在ViewModel中定义事件，视图订阅后触发自动化事件，耦合度略高于方案1，但实现简单。

修改ViewModel添加事件 #

public class MyViewModel
{
    public event EventHandler? ItemAdded;
    Dispatcher dispatcher;

    public MyViewModel()
    {
        dispatcher = Dispatcher.CurrentDispatcher;

        Task.Delay(5000).ContinueWith(_ =>
        {
            dispatcher.Invoke(() =>
            {
                ListOfStuff.Add("Item2");
                // 触发新增项事件
                ItemAdded?.Invoke(this, EventArgs.Empty);
            });
        });
    }

    public ObservableCollection<string> ListOfStuff { get; } = new ObservableCollection<string>() { "Item1" };
}

视图中订阅事件并触发自动化事件 #

首先给ListBox命名：

<ListBox x:Name="MyListBox"
         AutomationProperties.LiveSetting="Assertive" 
         AutomationProperties.Name="My list of things" 
         ItemsSource="{Binding ListOfStuff}"/>

然后在代码后台订阅事件：

public MainWindow()
{
    InitializeComponent();

    var vm = new MyViewModel();
    vm.ItemAdded += OnItemAdded;
    DataContext = vm;
}

private void OnItemAdded(object? sender, EventArgs e)
{
    var peer = FrameworkElementAutomationPeer.FromElement(MyListBox) ??
               FrameworkElementAutomationPeer.CreatePeerForElement(MyListBox);
    peer?.RaiseAutomationEvent(AutomationEvents.LiveRegionChanged);
}

方案3：自定义ObservableCollection触发通知 #

创建自定义集合类，在新增项时触发事件，视图订阅该事件后处理自动化逻辑。

自定义ObservableCollection #

public class ObservableCollectionWithItemAdded<T> : ObservableCollection<T>
{
    public event EventHandler<T>? ItemAdded;

    protected override void InsertItem(int index, T item)
    {
        base.InsertItem(index, item);
        ItemAdded?.Invoke(this, item);
    }
}

修改ViewModel使用自定义集合 #

public class MyViewModel
{
    Dispatcher dispatcher;

    public MyViewModel()
    {
        dispatcher = Dispatcher.CurrentDispatcher;

        Task.Delay(5000).ContinueWith(_ =>
        {
            dispatcher.Invoke(() =>
                ListOfStuff.Add("Item2")
            );
        });
    }

    public ObservableCollectionWithItemAdded<string> ListOfStuff { get; } = new ObservableCollectionWithItemAdded<string>() { "Item1" };
}

视图中订阅集合的ItemAdded事件 #

public MainWindow()
{
    InitializeComponent();

    var vm = new MyViewModel();
    vm.ListOfStuff.ItemAdded += OnListBoxItemAdded;
    DataContext = vm;
}

private void OnListBoxItemAdded(object? sender, string e)
{
    var peer = FrameworkElementAutomationPeer.FromElement(MyListBox) ??
               FrameworkElementAutomationPeer.CreatePeerForElement(MyListBox);
    peer?.RaiseAutomationEvent(AutomationEvents.LiveRegionChanged);
}

以上三种方案都能解决屏幕阅读器不播报新增项的问题，其中方案1的附加行为最符合MVVM设计原则，推荐使用。测试时可以继续使用Windows 11 Narrator，后续测试JAWS时也能兼容，因为LiveRegion是UI自动化的标准特性。

内容的提问来源于stack exchange，提问作者jqbd