EF层级TreeView全节点按Name排序及新增节点自动排序方案问询

你的问题核心在于：直接操作顶层集合的排序只对根节点生效，而子节点的ObservableCollection没有绑定到带排序逻辑的可观察视图；转换器返回的是一次性的IEnumerable，无法监听集合变更自动刷新排序。下面给你两种落地性强的解决方案，优先推荐第一种ViewModel包装的方式，扩展性和维护性更好。

方案一：用ViewModel层包装实体，给每个层级创建带排序的ICollectionView #

因为EF实体是数据模型，直接修改会破坏分层原则，我们在ViewModel层给每个实体做一层包装，统一处理排序和集合变更监听逻辑。

1. 先写通用的ViewModel基类 #

利用所有实体继承自BaseEntity的特性，抽象出通用的排序和子节点处理逻辑：

using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Runtime.CompilerServices;
using System.Windows.Data;

public abstract class EntityViewModelBase : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged;

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

    public int ID { get; protected set; }
    public string Name { get; protected set; }

    // 对外暴露的排序后子节点视图
    public ICollectionView ChildrenView { get; protected set; }

    // 子类需要实现：返回当前节点的子ViewModel集合
    protected abstract ObservableCollection<EntityViewModelBase> GetChildViewModels();

    protected EntityViewModelBase()
    {
        var childCollection = GetChildViewModels();
        if (childCollection == null) return;

        // 创建子节点的视图并添加排序规则
        ChildrenView = CollectionViewSource.GetDefaultView(childCollection);
        ChildrenView.SortDescriptions.Add(new SortDescription(nameof(Name), ListSortDirection.Ascending));

        // 监听子集合变更，确保新增/删除项时自动刷新排序
        childCollection.CollectionChanged += (_, __) => ChildrenView.Refresh();
    }
}

2. 给每个EF实体写对应的ViewModel #

以tblProject和tblLine为例，其他层级依此类推：

// tblProject对应的ViewModel
public class ProjectViewModel : EntityViewModelBase
{
    private readonly tblProject _entity;
    private readonly ObservableCollection<LineViewModel> _lineViewModels = new();

    public ProjectViewModel(tblProject project)
    {
        _entity = project;
        ID = project.ID;
        Name = project.Name;

        // 初始化现有子节点
        foreach (var line in project.Lines)
        {
            _lineViewModels.Add(new LineViewModel(line));
        }

        // 监听EF实体的子集合变更，同步到ViewModel集合
        _entity.Lines.CollectionChanged += (s, e) =>
        {
            if (e.NewItems != null)
            {
                foreach (tblLine line in e.NewItems)
                {
                    _lineViewModels.Add(new LineViewModel(line));
                }
            }
            if (e.OldItems != null)
            {
                foreach (tblLine line in e.OldItems)
                {
                    var vmToRemove = _lineViewModels.FirstOrDefault(vm => vm.ID == line.ID);
                    if (vmToRemove != null) _lineViewModels.Remove(vmToRemove);
                }
            }
        };
    }

    protected override ObservableCollection<EntityViewModelBase> GetChildViewModels()
    {
        return new ObservableCollection<EntityViewModelBase>(_lineViewModels);
    }
}

// tblLine对应的ViewModel
public class LineViewModel : EntityViewModelBase
{
    private readonly tblLine _entity;
    private readonly ObservableCollection<GroupViewModel> _groupViewModels = new();

    public LineViewModel(tblLine line)
    {
        _entity = line;
        ID = line.ID;
        Name = line.Name;

        foreach (var group in line.Groups)
        {
            _groupViewModels.Add(new GroupViewModel(group));
        }

        _entity.Groups.CollectionChanged += (s, e) =>
        {
            if (e.NewItems != null)
            {
                foreach (tblGroup group in e.NewItems)
                {
                    _groupViewModels.Add(new GroupViewModel(group));
                }
            }
            if (e.OldItems != null)
            {
                foreach (tblGroup group in e.OldItems)
                {
                    var vmToRemove = _groupViewModels.FirstOrDefault(vm => vm.ID == group.ID);
                    if (vmToRemove != null) _groupViewModels.Remove(vmToRemove);
                }
            }
        };
    }

    protected override ObservableCollection<EntityViewModelBase> GetChildViewModels()
    {
        return new ObservableCollection<EntityViewModelBase>(_groupViewModels);
    }
}

3. 主ViewModel绑定顶层集合 #

在你的主ViewModel（比如MainViewModel）中，把顶层EF实体转换成ViewModel集合，并创建排序视图：

public class MainViewModel : INotifyPropertyChanged
{
    private readonly YourDbContext _context;
    private readonly ObservableCollection<ProjectViewModel> _projectViewModels = new();
    public ICollectionView ProjectsView { get; }

    public MainViewModel(YourDbContext context)
    {
        _context = context;

        // 初始化顶层节点
        foreach (var project in context.tblProjects)
        {
            _projectViewModels.Add(new ProjectViewModel(project));
        }

        // 给顶层节点添加排序
        ProjectsView = CollectionViewSource.GetDefaultView(_projectViewModels);
        ProjectsView.SortDescriptions.Add(new SortDescription(nameof(Name), ListSortDirection.Ascending));

        // 监听EF上下文的顶层集合变更
        _context.tblProjects.Local.CollectionChanged += (s, e) =>
        {
            if (e.NewItems != null)
            {
                foreach (tblProject project in e.NewItems)
                {
                    _projectViewModels.Add(new ProjectViewModel(project));
                }
            }
            if (e.OldItems != null)
            {
                foreach (tblProject project in e.OldItems)
                {
                    var vmToRemove = _projectViewModels.FirstOrDefault(vm => vm.ID == project.ID);
                    if (vmToRemove != null) _projectViewModels.Remove(vmToRemove);
                }
            }
        };
    }

    public event PropertyChangedEventHandler PropertyChanged;
    protected void OnPropertyChanged(string propName) => PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propName));
}

4. XAML绑定TreeView #

直接绑定ViewModel的视图属性即可：

<TreeView ItemsSource="{Binding ProjectsView}">
    <TreeView.ItemTemplate>
        <HierarchicalDataTemplate ItemsSource="{Binding ChildrenView}">
            <TextBlock Text="{Binding Name}" />
        </HierarchicalDataTemplate>
    </TreeView.ItemTemplate>
</TreeView>

方案二：用附加属性给TreeView节点自动添加排序（无需ViewModel） #

如果不想写大量ViewModel，可以用WPF附加属性，自动给每个层级的集合创建排序视图。不过这个方案要求你能统一子集合的属性名（比如所有实体的子集合都叫Children），或者通过附加属性指定每个层级的子集合路径。

1. 写附加属性类 #

using System.Collections;
using System.Collections.ObjectModel;
using System.Reflection;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;

public static class TreeViewSortHelper
{
    public static readonly DependencyProperty SortPathProperty =
        DependencyProperty.RegisterAttached("SortPath", typeof(string), typeof(TreeViewSortHelper), new PropertyMetadata(null, OnSortPathChanged));

    public static string GetSortPath(DependencyObject obj) => (string)obj.GetValue(SortPathProperty);
    public static void SetSortPath(DependencyObject obj, string value) => obj.SetValue(SortPathProperty, value);

    // 子集合属性名的附加属性，用于指定每个层级的子集合字段
    public static readonly DependencyProperty ChildCollectionPathProperty =
        DependencyProperty.RegisterAttached("ChildCollectionPath", typeof(string), typeof(TreeViewSortHelper), new PropertyMetadata("Children"));

    public static string GetChildCollectionPath(DependencyObject obj) => (string)obj.GetValue(ChildCollectionPathProperty);
    public static void SetChildCollectionPath(DependencyObject obj, string value) => obj.SetValue(ChildCollectionPathProperty, value);

    private static void OnSortPathChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        if (d is TreeView treeView)
        {
            treeView.Loaded += TreeView_Loaded;
        }
    }

    private static void TreeView_Loaded(object sender, RoutedEventArgs e)
    {
        var treeView = sender as TreeView;
        if (treeView == null || string.IsNullOrEmpty(GetSortPath(treeView))) return;

        // 容器生成完成后应用排序
        treeView.ItemContainerGenerator.StatusChanged += (s, args) =>
        {
            if (treeView.ItemContainerGenerator.Status == GeneratorStatus.ContainersGenerated)
            {
                ApplySortRecursively(treeView.Items, GetSortPath(treeView), GetChildCollectionPath(treeView));
            }
        };
    }

    private static void ApplySortRecursively(IEnumerable items, string sortPath, string childCollectionPath)
    {
        foreach (var item in items)
        {
            // 通过反射获取子集合
            var childProp = item.GetType().GetProperty(childCollectionPath);
            if (childProp == null) continue;

            var childCollection = childProp.GetValue(item) as ObservableCollection<object>;
            if (childCollection == null) continue;

            // 给子集合创建排序视图
            var view = CollectionViewSource.GetDefaultView(childCollection);
            view.SortDescriptions.Clear();
            view.SortDescriptions.Add(new SortDescription(sortPath, ListSortDirection.Ascending));

            // 递归处理子节点
            ApplySortRecursively(view, sortPath, childCollectionPath);

            // 监听子集合变更，自动刷新排序
            ((INotifyCollectionChanged)childCollection).CollectionChanged += (_, __) => view.Refresh();
        }
    }
}

2. XAML中使用附加属性 #

<TreeView 
    local:TreeViewSortHelper.SortPath="Name"
    local:TreeViewSortHelper.ChildCollectionPath="Lines" <!-- 这里要对应顶层实体的子集合属性名，比如tblProject的Lines -->
    ItemsSource="{Binding TreeSetup.Items}">
    <TreeView.ItemTemplate>
        <HierarchicalDataTemplate ItemsSource="{Binding Lines}">
            <TextBlock Text="{Binding Name}" />
            <!-- 下一层级的DataTemplate需要指定对应的子集合路径，比如Groups -->
            <HierarchicalDataTemplate.ItemTemplate>
                <HierarchicalDataTemplate ItemsSource="{Binding Groups}">
                    <TextBlock Text="{Binding Name}" />
                    <!-- 继续往下嵌套直到最底层 -->
                </HierarchicalDataTemplate>
            </HierarchicalDataTemplate.ItemTemplate>
        </HierarchicalDataTemplate>
    </TreeView.ItemTemplate>
</TreeView>

为什么之前的方案失效？ #

• 直接给TreeSetup.Items加SortDescriptions：只对顶层的ICollectionView生效，子节点的集合是实体内部的ObservableCollection，没有被包装成带排序的视图，自然不会排序。
• 转换器返回OrderBy结果：OrderBy返回的是一次性的IEnumerable，不会监听原集合的变更，新增节点时转换器不会重新执行，视图也就不会更新。而ICollectionView会自动监听原ObservableCollection的变更，实时刷新排序。

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