如何在嵌套属性变更时触发ObservableCollection的CollectionChanged事件

Great question—this is a common point of confusion when working with ObservableCollection in MVVM. Let’s break this down clearly, covering both how to achieve the behavior you’re asking for and whether it’s the standard approach.

How to Trigger CollectionChanged When a Nested Property (Chapter.Name) Changes #

First, let’s get one key fact out of the way: the built-in ObservableCollection<T> only fires CollectionChanged when items are added, removed, reordered, or replaced in the collection. It does not monitor changes to the properties of the items themselves—even nested properties like Book.Chapter.Name.

To make CollectionChanged fire when Chapter.Name changes, you’ll need to extend the collection to listen for property changes on its items, then manually trigger the event. Here’s how to do it properly:

Step 1: Ensure Your Models Implement INotifyPropertyChanged #

First, both Book and Chapter need to raise PropertyChanged events when their properties change. For nested properties like Chapter.Name, we’ll also propagate that change up to the Book level so the collection can catch it:

using System.ComponentModel;
using System.Runtime.CompilerServices;

public class Chapter : INotifyPropertyChanged
{
    private string _name;
    public string Name
    {
        get => _name;
        set
        {
            if (_name != value)
            {
                _name = value;
                OnPropertyChanged();
            }
        }
    }

    public event PropertyChangedEventHandler PropertyChanged;
    protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
}

public class Book : INotifyPropertyChanged
{
    private Chapter _chapter;
    public Chapter Chapter
    {
        get => _chapter;
        set
        {
            if (_chapter != value)
            {
                // Unsubscribe from the old chapter's events if it exists
                if (_chapter != null)
                    _chapter.PropertyChanged -= Chapter_PropertyChanged;
                
                _chapter = value;
                
                // Subscribe to the new chapter's events
                if (_chapter != null)
                    _chapter.PropertyChanged += Chapter_PropertyChanged;
                
                OnPropertyChanged();
            }
        }
    }

    // Propagate changes from Chapter.Name up to Book's PropertyChanged
    private void Chapter_PropertyChanged(object sender, PropertyChangedEventArgs e)
    {
        if (e.PropertyName == nameof(Chapter.Name))
            OnPropertyChanged(nameof(Chapter));
    }

    public event PropertyChangedEventHandler PropertyChanged;
    protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
}

Step 2: Create a Custom ObservableCollection #

Next, build a subclass of ObservableCollection<T> that subscribes to each item’s PropertyChanged event. When an item’s property changes, we’ll trigger CollectionChanged using the Replace action (since the item’s content has effectively been replaced):

public class ObservableItemCollection<T> : ObservableCollection<T> where T : INotifyPropertyChanged
{
    protected override void OnCollectionChanged(NotifyCollectionChangedEventArgs e)
    {
        // Unsubscribe from old items when they're removed from the collection
        if (e.OldItems != null)
        {
            foreach (INotifyPropertyChanged item in e.OldItems)
            {
                item.PropertyChanged -= Item_PropertyChanged;
            }
        }

        // Subscribe to new items when they're added
        if (e.NewItems != null)
        {
            foreach (INotifyPropertyChanged item in e.NewItems)
            {
                item.PropertyChanged += Item_PropertyChanged;
            }
        }

        base.OnCollectionChanged(e);
    }

    private void Item_PropertyChanged(object sender, PropertyChangedEventArgs e)
    {
        // Find the index of the changed item and trigger CollectionChanged
        var changedItem = (T)sender;
        var index = IndexOf(changedItem);
        
        if (index >= 0)
        {
            OnCollectionChanged(new NotifyCollectionChangedEventArgs(
                NotifyCollectionChangedAction.Replace, changedItem, changedItem, index));
        }
    }
}

Step 3: Use the Custom Collection in Your ViewModel #

Now just replace your standard ObservableCollection<Book> with the custom one:

public class YourViewModel
{
    public ObservableItemCollection<Book> Books { get; } = new ObservableItemCollection<Book>();
}

With this setup, when Book.Chapter.Name changes, the event will propagate up to the Book, the custom collection will catch it, and fire CollectionChanged.

Is Manual Notification the Standard MVVM Approach? #

In short: No, this isn’t the standard practice. Here’s why:

• The core purpose of ObservableCollection<T> is to notify the UI about changes to the collection’s structure (adding/removing items), not changes to item properties.
• The standard MVVM pattern relies on individual model classes implementing INotifyPropertyChanged (as we did in Step 1). When you bind UI elements directly to properties like Book.Chapter.Name, the UI will automatically update whenever that property changes—you don’t need to trigger CollectionChanged at all.
• Manually triggering CollectionChanged for property changes should only be done in niche cases, such as:
  • You have a component that depends on the entire collection’s state (e.g., a total count or summary that needs to refresh when any item changes).
  • You’re using a third-party control that only listens to CollectionChanged and doesn’t handle individual property updates.

For most everyday MVVM scenarios, stick to letting each model handle its own property change notifications, and reserve CollectionChanged for actual collection structure changes.

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