MVVM：双向模型元素的视图模型

Question

假设我有以下模型结构：

class Team {
    public string Name {get;set; }
    public List<Player> players {get;set;}
}

class Player {
    public int Age {get;set;}
    public string Name {get;set;}
    public Team Team {get;set;}
}

我希望为此模型创建视图模型。但是，我也想避免在 TeamVM 中复制 Player 的所有属性，反之亦然（对于这个简单的示例，这是可行的，但实际上相当麻烦）。

查看文献和在线文章，似乎“纯粹”的方式是为每个模型创建一个 ViewModel，并且让一个 ViewModel 只返回其他 ViewModel 而从不返回 Model。这一切都很好，但我的问题是：如何在不陷入递归陷阱的情况下创建这些视图模型。假设我这样做：

public class TeamVM: ViewModel<Team> {

   private ObservableCollection<PlayerVM> _players;

   public TeamVM(Team t): base(t) {
       _players = new ObservableCollection();
       foreach (Player p in t.players) {
          _players.Add(new PlayerVM(t));
       }
   }

   public string Name {
      get { return _modelElement.Name; }
      set { _modelElement.Name = value; NotifyPropertyChanged(); }
   }

   public ObservableCollection<PlayerVM> Players {
      get { return _players; }
   }
}

和

public class PlayerVM : ViewModel<Player> {

   private TeamVM _teamVM;

   public PlayerVM(Player p): base(p) {
       _teamVm = new TeamVM(p.Team);
   }

   public int Age {
      get { return _modelElement.Age; }
      set { _modelElement.Age = value; NotifyPropertyChanged(); }
   }
   public string Name {
      get { return _modelElement.Name; }
      set { _modelElement.Name = value; NotifyPropertyChanged(); }
   }
   public TeamVM Team {
      get { return _teamVM; }
      set { _teamVm = value; NotifyPropertyChanged(); }
   }
}

显然，上述方法永远不会起作用，因为它会创建递归：创建 TeamVM 会导致创建 PlayerVM，而 PlayerVM 又会再次生成 TeamVM，等等。

现在，我通过添加如下中间类解决了这个问题：

public class TeamMinimalVM: ViewModel<Team> {

   public TeamVM(Team t): base(t) {
   }

   public string Name {
      get { return _modelElement.Name; }
      set { _modelElement.Name = value; NotifyPropertyChanged(); }
   }
}

public class TeamVM: TeamMinimalVM {

   private ObservableCollection<PlayerVM> _players;

   public TeamVM(Team t): base(t) {
       _players = new ObservableCollection();
       foreach (Player p in t.players) {
          _players.Add(new PlayerVM(t));
       }
   }
}

然后让 PlayerVM 依赖于 TeamMinimalVM 而不是 TeamVM。这意味着在视图中，您可以执行以下操作：{Binding Player.Team.Name} 但不能执行 {Binding Player.Team.Players.Name}，我想这对我来说还可以，因为我不认为无论如何，这样做是个好主意。

我现在的问题是：是否有更好/更“标准”的方式来执行双向模型元素的“纯”虚拟机？我不想将一种类型的属性克隆到另一种类型中（太多了），也不想直接公开 Model 元素。

最后，我使用的 ViewModel 类就是这个（只是为了完整性，但它对我认为的问题并不重要。）

public class ModelElementViewModel<T> : ObservableObject where T : class 
{
    private bool _modelElementChanged;
    private T _modelElement;

    public ModelElementViewModel(T element)
    {
        _modelElement = element;
    }

    /// <summary>
    /// The underlying model element for this viewmodel. Protected as one should not bind directly to model elements from the gui.
    /// </summary>
    internal T ModelElement {
        get { return _modelElement; }
        set {
            if (_modelElement != value)
            {
                _modelElement = value;
                ModelElementChanged = false;
                NotifyAllPropertiesChanged();
            }
            ; }
    }

    /// <summary>
    /// Property that can be used to see if the underlying modelelement was changed through this viewmodel (note that an external 
    /// change to the model element is not tracked!)
    /// </summary>
    public bool ModelElementChanged {
        private set
        {
            if (_modelElementChanged != value)
            {
                _modelElementChanged = value;
                NotifyPropertyChanged();
            }
        }
        get
        {
            return _modelElementChanged;
        }
    }

    protected override void NotifyPropertyChanged([CallerMemberName] string propertyName = "")
    {
        ModelElementChanged = true;
        base.NotifyPropertyChanged(propertyName);
    }

}

编辑：

我最初的问题并不清楚的是，球员并不是由球队专门使用的。我希望以下三种情况起作用：

1. 我希望能够为单个玩家创建一个显示所有玩家信息的视图
2. 我希望能够为球队创建一个视图，显示该球队的信息以及所有球员及其统计数据的表格
3. 例如，我还希望能够拥有一个 Playersbook 视图，该视图由一个表格组成，其中显示所有已知球员及其团队名称。

Answer 1

您的班级有一个明确的层次结构：团队聚集了球员。球队是所有者，球员是所有者。因此，在创建玩家虚拟机时，您可以将团队虚拟机作为构造函数参数传递。

这样做的明显限制是现在你不能有没有球队的球员。可能的解决方案是：强制玩家始终由某个团队拥有；支持 null 作为团队 VM 并在以后设置适当的值；创建一个“空团队”对象并将其用于无团队玩家。

在这种情况下，如果聚合层次结构清晰，我会使用我的OwnedObservableCollection<T, TOwner>。有了它，我可以在团队中创建一个集合_players = new OwnedObservableCollection<PlayerVM, TeamVM>(this)，然后只需使用Add 和Remove 在团队中添加和删除玩家。