WPF MVVM架构下，如何在ViewModel中处理Model列表？

核心思路是在ViewModel层维护与Model子节点对应的ViewModel集合，通过ObservableCollection实现视图的变化感知，同时严格保持Model与ViewModel的分离，不破坏架构原则。以下是具体实现方案：

1. 优化Model层（可选但推荐） #

如果允许调整NodeModel，将子节点集合改为ObservableCollection<NodeModel>，这样可以自动监听Model层的集合变化，方便ViewModel同步：

public class NodeModel
{
    public string Content { get; set; }
    public Vector2 Position { get; set; }
    public NodeModel? ParentNode { get; set; }
    // 替换List为ObservableCollection，支持集合变更通知
    public ObservableCollection<NodeModel> ChildrenNodes { get; } = new ObservableCollection<NodeModel>();
}

如果必须保留List<NodeModel>，可以跳过这一步，改用手动同步的方式（见后文）。

2. 实现完整的NodeViewModel #

ViewModel需要持有Model引用，维护对应的子节点ViewModel集合，并处理Model与ViewModel的双向同步：

public class NodeViewModel : ViewModelBase, IDisposable
{
    private readonly NodeModel _model;
    private ObservableCollection<NodeViewModel>? _childrenViewModels;

    // 内容属性：双向同步Model与ViewModel
    public string Content
    {
        get => _model.Content;
        set
        {
            if (_model.Content != value)
            {
                _model.Content = value;
                OnPropertyChanged(nameof(Content));
            }
        }
    }

    // 位置属性：双向同步
    public Vector2 Position
    {
        get => _model.Position;
        set
        {
            if (_model.Position != value)
            {
                _model.Position = value;
                OnPropertyChanged(nameof(Position));
            }
        }
    }

    // 父节点ViewModel，替代直接暴露Model
    public NodeViewModel? ParentViewModel { get; private set; }

    // 子节点ViewModel集合，视图绑定此属性
    public ObservableCollection<NodeViewModel> ChildrenViewModels
    {
        get
        {
            if (_childrenViewModels == null)
            {
                // 从Model的子节点初始化ViewModel集合
                _childrenViewModels = new ObservableCollection<NodeViewModel>(
                    _model.ChildrenNodes.Select(model => new NodeViewModel(model, this))
                );
                // 监听Model集合的变化，自动同步ViewModel
                if (_model.ChildrenNodes is INotifyCollectionChanged notifyCollection)
                {
                    notifyCollection.CollectionChanged += OnModelChildrenChanged;
                }
            }
            return _childrenViewModels;
        }
    }

    // 构造函数：传入Model和父ViewModel
    public NodeViewModel(NodeModel model, NodeViewModel? parentViewModel = null)
    {
        _model = model ?? throw new ArgumentNullException(nameof(model));
        ParentViewModel = parentViewModel;

        // 监听Model的属性变化（需Model实现INotifyPropertyChanged）
        if (_model is INotifyPropertyChanged notifyModel)
        {
            notifyModel.PropertyChanged += OnModelPropertyChanged;
        }
    }

    // 同步Model的属性变化到ViewModel
    private void OnModelPropertyChanged(object? sender, PropertyChangedEventArgs e)
    {
        switch (e.PropertyName)
        {
            case nameof(NodeModel.Content):
                OnPropertyChanged(nameof(Content));
                break;
            case nameof(NodeModel.Position):
                OnPropertyChanged(nameof(Position));
                break;
            // 其他需要同步的属性同理
        }
    }

    // 同步Model的集合变化到ViewModel集合
    private void OnModelChildrenChanged(object? sender, NotifyCollectionChangedEventArgs e)
    {
        if (_childrenViewModels == null) return;

        switch (e.Action)
        {
            case NotifyCollectionChangedAction.Add:
                foreach (NodeModel newModel in e.NewItems!)
                {
                    _childrenViewModels.Add(new NodeViewModel(newModel, this));
                }
                break;
            case NotifyCollectionChangedAction.Remove:
                foreach (NodeModel oldModel in e.OldItems!)
                {
                    var vmToRemove = _childrenViewModels.FirstOrDefault(vm => vm._model == oldModel);
                    if (vmToRemove != null)
                    {
                        _childrenViewModels.Remove(vmToRemove);
                        vmToRemove.Dispose();
                    }
                }
                break;
            case NotifyCollectionChangedAction.Reset:
                _childrenViewModels.Clear();
                foreach (var model in _model.ChildrenNodes)
                {
                    _childrenViewModels.Add(new NodeViewModel(model, this));
                }
                break;
            // 按需处理Move、Replace等操作
        }
    }

    // 清理事件订阅，避免内存泄漏
    public void Dispose()
    {
        if (_model is INotifyPropertyChanged notifyModel)
        {
            notifyModel.PropertyChanged -= OnModelPropertyChanged;
        }
        if (_model.ChildrenNodes is INotifyCollectionChanged notifyCollection)
        {
            notifyCollection.CollectionChanged -= OnModelChildrenChanged;
        }
        foreach (var childVm in ChildrenViewModels)
        {
            childVm.Dispose();
        }
        GC.SuppressFinalize(this);
    }
}

3. 若无法修改Model的集合类型（保留List） #

如果必须用List<NodeModel>，则需要通过ViewModel的方法手动控制子节点的增删，确保Model与ViewModel集合同步：

// 在NodeViewModel中添加以下方法
public void AddChild(NodeModel childModel)
{
    _model.ChildrenNodes.Add(childModel);
    ChildrenViewModels.Add(new NodeViewModel(childModel, this));
}

public bool RemoveChild(NodeViewModel childVm)
{
    var targetModel = _model.ChildrenNodes.FirstOrDefault(m => childVm._model == m);
    if (targetModel == null) return false;
    
    _model.ChildrenNodes.Remove(targetModel);
    ChildrenViewModels.Remove(childVm);
    childVm.Dispose();
    return true;
}

所有子节点的增删操作都需调用这些方法，不能直接操作Model的List，否则ViewModel集合不会同步。

关键设计要点 #

• 严格分离Model与ViewModel：Model仅负责数据存储，ViewModel处理UI相关的通知和映射，完全符合MVVM架构原则。
• ObservableCollection实现视图感知：WPF的ItemsControl（如TreeView、ItemsControl）会自动监听ObservableCollection的变化，无需手动更新视图。
• 双向同步：既支持从ViewModel修改同步到Model，也支持Model层数据变化时同步到ViewModel（需Model实现INotifyPropertyChanged）。
• 内存泄漏防护：通过IDisposable清理事件订阅，避免ViewModel被Model引用无法回收。

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