c# - POCO 和实用方法

Question

假设我有一个包含 foos 和 bars 的 POCO 类:

public class Poco {
  public IEnumerable<Foo> Foos { get { return foos; } }
  public IEnumerable<Bar> Bars { get { return bars; } }

  private List<Foo> foos;
  private List<Bar> bars;
}

在我的示例中，我需要能够添加和删除 foos 和 bars:

public class Poco {
  public IList<Foo> Foos { get { return foos; } }
  public IList<Bar> Bars { get { return bars; } }

  private List<Foo> foos;
  private List<Bar> bars;
}

但是假设我还需要(任意)约束，即每个 bar 必须有一个 foo 并且每个 bar 必须有一个 foo。

public class NotAPocoAnyMore {
  public IEnumerable<Foo> Foos { get { return foos; } }
  public IEnumerable<Bar> Bars { get { return bars; } }

  private List<Foo> foos;
  private List<Bar> bars;

  public void Add(Foo f, Bar b) {...}
  public void Remove(Foo f, Bar b) {...}
}

我的问题是:我是否开始努力让 POCO 保持简单而不给它任何实用方法？第一个示例 POCO 很好，因为它是不可变的，而且 POCO 还有其他优势。但是，我看不出有什么方法可以让该类保持 POCO，并且仍然有办法以受控方式访问和修改内容(至少不是一种看起来不过分的方式)。

我曾经有过的一些想法:

嵌套修改类

public class Poco {
  public IEnumerable<Foo> Foos { get { return foos; } }
  public IEnumerable<Bar> Bars { get { return bars; } }
  public PocoModifier Modifier { get { ... } }

  private List<Foo> foos;
  private List<Bar> bars;

  public class PocoModifier {
    private readonly Poco toModify;
    public void Add(Foo f, Bar b) {...}
    public void Remove(Foo f, Bar b) {...}
    ...
  }
}

公共(public)嵌套类？不，谢谢!此外，它实际上与非 POCO 类相同，只是多了一点嵌套。

使用访问修饰符

public class Poco {
  public IEnumerable<Foo> Foos { get { return foos; } }
  public IEnumerable<Bar> Bars { get { return bars; } }
  public PocoModifier Modifier { get { ... } }

  internal List<Foo> foos;
  internal List<Bar> bars;
}

public class PocoModifier {
  private readonly Poco toModify;
  public void Add(Foo f, Bar b) {...}
  public void Remove(Foo f, Bar b) {...}
  ...
}

稍微好一点，但每个 POCO 都需要一个完整的部署单元。

Answer 1

听起来您的数据可以通过自然地将 Foo 与 Bar 配对的东西更好地建模。

public class Poco {
  public IList<Tuple<Foo, Bar>> FooBars { get { return fooBars; } }

  private List<Tuple<Foo, Bar>> fooBars;
}

除非出于某些奇怪的原因，Foo 和 Bar 是完全分开的，只是要求它们的计数相同。那么我喜欢你的第三个例子......

public class NotAPocoAnyMore {
  public IEnumerable<Foo> Foos { get { return foos; } }
  public IEnumerable<Bar> Bars { get { return bars; } }

  private List<Foo> foos;
  private List<Bar> bars;

  public void Add(Foo f, Bar b) {...}
  public void Remove(Foo f, Bar b) {...}
}

PocoModifier 在我看来增加了不必要的复杂性。嵌套类通常不应公开(因此，如果您有类，请像上一个示例一样将其分开)。

如果您还需要一个 POCO(例如，将其公开给使用您的代码作为库的人，同时将其他逻辑保留在内部)，您可以创建一个普通的 POCO，然后将其映射到 NotAPocoAnyMore 与 AutoMapper (或类似的)。

public class Poco {
  public IList<Foo> Foos { get; set; }
  public IList<Bar> Bars { get; set; }
}