使用部分类在C＃中模拟C ++友谊

Question

我有以下情况：

我需要创建一个树形结构，该结构一旦实例化，就是不可变的。例如，考虑一个列表方法列表。 问题是在构建期间，我需要能够插入节点。 因此，我需要某种私有接口，允许插入节点，而此结构的公共接口仅允许检索节点。 我尝试了这个：

public partial class TreeLike {
  public SomeType1 SomeTreeProperty1 { get; private set; }
  public SomeType2 SomeTreeProperty2 { get; private set; }

  private List<NodeLike> _Nodes = new List<NodeLike>();
  public ReadOnlyCollection<NodeLike> Nodes {
    get {
      return _Nodes.AsReadOnly();
    }
  }
}

public class NodeLike {
  public SomeType1 SomeNodeProperty { get; private set; }

  private List<NodeLike> _Children = new List<NodeLike>();
  public ReadOnlyCollection<NodeLike> Children {
    get {
      return _Children.AsReadOnly();
    }
  }

  public partial class TreeLike {
    public SomeType3 SomeTreeProperty3 { get; private set; }

    TreeLike() {
      NodeLike n0 = new NodeLike();
      NodeLike n1 = new NodeLike();
      n0._Children.Add(n1);
      _Nodes.Add(n0);
    }
  }
}

与此问题（除了继续的有所hackysh看TreeLike里面的声明/定义NodeLike ），是，虽然它的工作原理， SomeTreeProperty3的TreeLike不是外界可见。 也就是说，如果我在最大范围内创建TreeLike的实例，则只能访问第一个访问部分类的“全局”范围声明中声明的属性。

因此，我想知道是否有办法在部分范围的嵌套延续中声明的属性和方法仍然对全局范围可见（因此，该类的客户端）。 或者，如果没有，那么一种更好的C＃惯用的方式是什么呢？ 也许创建类的不变版本？

Answer 1

您应该只在构造函数内部执行所有初始化，因为它允许您使用只读字段实现真正的不变性。

例如，如果您的节点接口是这样定义的：

interface INode
{
    public string Name { get; }
    public ReadOnlyCollection<INode> Children { get; }
}

那么一个实现应该简单地是：

class Node : INode
{
    private readonly string _name;
    public string Name
    {
        get { return _name; }
    }

    private readonly ReadOnlyCollection<INode> _children;
    public ReadOnlyCollection<INode> Children
    {
        get { return _children; }
    }

    public Node(string name, IEnumerable<INode> children)
    {
        _name = name;
        _children = new List<INode>(children).AsReadOnly();
    }

    public Node(string name, params INode[] children)
        : this(name, (IEnumerable<INode>)children)
    { }
}

最后一个构造函数重载使用params关键字允许您直接通过构造函数传递子节点，这意味着您可以执行以下操作：

var root = new Node(
    "root",
    new Node("left",
        new Node("left-left"),
        new Node("left-right")),
    new Node("right",
        new Node("right-left"),
        new Node("right-right"))
    );

Answer 2

可能的设计要求解决方案可能看起来像这样：

public partial class TreeLike {
    public SomeType1 SomeTreeProperty1 { get; private set; }
    public SomeType2 SomeTreeProperty2 { get; private set; }
    public SomeType3 SomeTreeProperty3 { get; private set; }

    private List<NodeLike> _Nodes = new List<NodeLike>();
    public ReadOnlyCollection<NodeLike> Nodes {
        get {
            return _Nodes.AsReadOnly();
        }
    }

    TreeLike() {
        NodeLike n1 = new NodeLike();
        NodeLike n0 = new NodeLike(n1);

        _Nodes.Add(n0);
    }
}

public class NodeLike {
    public SomeType1 SomeNodeProperty { get; private set; }

    private List<NodeLike> _Children = new List<NodeLike>();
    public ReadOnlyCollection<NodeLike> Children {
        get {
            return _Children.AsReadOnly();
    }

    public NodeLike(params NodeLike[] children) {
        _Children = children.ToList();
    }
}

partial与这个问题无关。 params是一种有用的语法，它使您还可以执行以下操作：

new NodeLike(childNode1, childNode2, childNode3);

旁注： 在C＃中不建议使用埃及括号。