WPF中合并多层嵌套ObservableCollection并同步更新TreeView

刚好之前做过类似的WPF TreeView绑定嵌套集合的需求，给你几个实用的解决方案，都能实现底层集合变更时UI自动同步，不用重新绑定：

1. 用HierarchicalDataTemplate递归绑定（最推荐，原生玩法最省心） #

WPF的TreeView本身就支持层级数据的渲染，直接利用HierarchicalDataTemplate就能搞定N级嵌套的场景，而且完全依赖ObservableCollection的INotifyCollectionChanged特性，底层集合增删改会自动同步到UI，根本不用手动重新绑定。

具体步骤： #

• 先给你的Rule类加一个ObservableCollection<Rule>类型的子节点属性（比如叫Children）。如果原来的RuleApp结构里子集合不是直接挂在Rule上，就用属性包装的方式把嵌套子集合暴露出来：

public class Rule : INotifyPropertyChanged
{
    // 原有业务属性
    public string RuleName { get; set; }

    // 包装子集合，从RuleApp的嵌套结构中获取当前规则的子规则
    private ObservableCollection<Rule> _children;
    public ObservableCollection<Rule> Children
    {
        get 
        {
            if (_children == null)
                _children = RuleApp.GetChildRules(this); // 替换成你实际获取子集合的逻辑
            return _children;
        }
        set
        {
            _children = value;
            OnPropertyChanged(nameof(Children));
        }
    }

    // 实现INotifyPropertyChanged接口，这里省略具体代码
    public event PropertyChangedEventHandler PropertyChanged;
    protected void OnPropertyChanged(string propertyName)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
}

• 然后在XAML里定义递归的模板：

<TreeView ItemsSource="{Binding RuleApp.RootRules}">
    <TreeView.ItemTemplate>
        <HierarchicalDataTemplate ItemsSource="{Binding Children}">
            <TextBlock Text="{Binding RuleName}" />
            <!-- 这里可以自定义每个节点的UI，比如加图标、状态标识等 -->
        </HierarchicalDataTemplate>
    </TreeView.ItemTemplate>
</TreeView>

这样不管嵌套多少级，TreeView都会自动递归渲染，而且任何层级的子集合增删改，UI都会即时更新，完全不用管同步逻辑。

2. 自定义递归监听的扁平化集合（适合不能改原有结构的场景） #

如果因为历史原因没法修改Rule类的结构，必须用扁平化集合绑定，那可以自己写一个能递归监听所有嵌套ObservableCollection的自定义集合，自动同步所有层级的元素。

核心思路： #

创建一个CompositeObservableCollection<T>，它会递归遍历所有嵌套的ObservableCollection，监听它们的CollectionChanged事件，一旦有增删改操作，就自动更新自身的元素。

简化版代码示例： #

public class CompositeObservableCollection<T> : ObservableCollection<T>
{
    private readonly Func<T, IEnumerable<T>> _getChildItems;
    private readonly List<INotifyCollectionChanged> _watchedCollections = new();

    public CompositeObservableCollection(Func<T, IEnumerable<T>> getChildItems)
    {
        _getChildItems = getChildItems;
    }

    public void LoadRecursive(IEnumerable<T> rootItems)
    {
        Clear();
        _watchedCollections.ForEach(c => c.CollectionChanged -= OnChildCollectionChanged);
        _watchedCollections.Clear();

        AddItemsRecursive(rootItems);
    }

    private void AddItemsRecursive(IEnumerable<T> items)
    {
        foreach (var item in items)
        {
            Add(item);

            // 监听当前项的子集合
            var childCollection = _getChildItems(item) as INotifyCollectionChanged;
            if (childCollection != null && !_watchedCollections.Contains(childCollection))
            {
                childCollection.CollectionChanged += OnChildCollectionChanged;
                _watchedCollections.Add(childCollection);
                AddItemsRecursive(_getChildItems(item));
            }
        }
    }

    private void OnChildCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
    {
        switch (e.Action)
        {
            case NotifyCollectionChangedAction.Add:
                foreach (var newItem in e.NewItems.Cast<T>())
                {
                    Add(newItem);
                    AddItemsRecursive(_getChildItems(newItem));
                }
                break;
            case NotifyCollectionChangedAction.Remove:
                foreach (var oldItem in e.OldItems.Cast<T>())
                {
                    Remove(oldItem);
                    // 停止监听被移除项的子集合
                    var childCollection = _getChildItems(oldItem) as INotifyCollectionChanged;
                    if (childCollection != null && _watchedCollections.Contains(childCollection))
                    {
                        childCollection.CollectionChanged -= OnChildCollectionChanged;
                        _watchedCollections.Remove(childCollection);
                    }
                }
                break;
            // 可以根据需求处理Reset、Replace等其他操作
        }
    }
}

使用方式： #

// 初始化集合，传入获取子集合的逻辑
var flatCollection = new CompositeObservableCollection<Rule>(rule => RuleApp.GetChildRules(rule));
// 加载根规则集合
flatCollection.LoadRecursive(RuleApp.RootRules);
// 绑定到TreeView
treeView.ItemsSource = flatCollection;

这样不管哪个层级的子集合变了，这个扁平化集合都会自动同步，TreeView也会跟着更新。

3. 用CollectionViewSource分组（适合层级可通过属性区分的场景） #

如果你的Rule类有明确的层级标识属性（比如Level、ParentId），可以用CollectionViewSource做分组绑定，底层集合变更时分组会自动更新。

XAML示例： #

<Window.Resources>
    <CollectionViewSource x:Key="RuleGroupSource" Source="{Binding AllRules}">
        <CollectionViewSource.GroupDescriptions>
            <!-- 按Level属性分组，替换成你实际的层级标识属性 -->
            <PropertyGroupDescription PropertyName="Level" />
        </CollectionViewSource.GroupDescriptions>
    </CollectionViewSource>
</Window.Resources>

<TreeView ItemsSource="{Binding Source={StaticResource RuleGroupSource}}">
    <TreeView.ItemTemplate>
        <HierarchicalDataTemplate ItemsSource="{Binding Items}">
            <TextBlock Text="{Binding RuleName}" />
        </HierarchicalDataTemplate>
    </TreeView.ItemTemplate>
    <TreeView.GroupStyle>
        <GroupStyle>
            <GroupStyle.HeaderTemplate>
                <DataTemplate>
                    <TextBlock Text="Level {Binding Name}" FontWeight="Bold" />
                </DataTemplate>
            </GroupStyle.HeaderTemplate>
        </GroupStyle>
    </TreeView.GroupStyle>
</TreeView>

这个方案适合层级结构比较规整的场景，不用处理递归监听，依赖WPF的分组机制自动同步。

总结一下，优先选方案1，完全贴合WPF的原生设计，代码最少也最稳定；如果没法修改原有实体结构，再考虑方案2；方案3适合层级可通过属性直接区分的特定场景。

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