Question

public class ParentClass
{
    public int myId;
    public string commonField1;
    public string commonField2;
    public string commonField3;
    public string changeable;
    public List<ChildClass> children;

    public ParentClass(int id)
    {
        myId = myId;
    }

    public createChildren()
    {
        for(int i = 0; i < 999999; i++) 
        {
            children.Add(new ChildClass(id));
        }
    }
}

public class ChildClass : ParentClass
{
    public ChildClass(int id) : base (id) 
    {
        myId = myId;
        changeable = "new";
    }
}

因为ChildClass仅存在于其父级的上下文中，并且将有999999个子级。这就是创建所有999999的{{1}}个副本，而实际上它只需要引用它的父级。 commonField除了引用之外唯一需要存储的真实内容是ChildClass。

如何实现这一目标？

我几乎在想一个更好的方法，当我需要孩子时只需要制作999999个ParentClass的浅拷贝，只需更改999999可更改字段。浅拷贝会引用changeable还是深层复制值？

Answer 1

如果commonFieldX真的不变，那么你有一件事是正确的，那就是重复数据很多。

我看到了几个解决方案：

首选组合而不是继承

你为什么要继承？如果没有多态行为，那么只需将基类实例传递给10000个子节点并调用它：

public createChildren()
{
    for(int i = 0; i < 999999; i++) {
         children.Add(new ChildClass(id, this));
    }
}

public class ChildClass
{
     public ChildClass(int id, ParentClass parent) : base (id) 
     {
           myId = myId; //This shouldn't be part of the base class?
           changeable = "new"; //Same here
           myParent = parent;
     }
}

在所有实例中共享这些变量

static成员属于＆＃34;全球＆＃34;实例，因此不会为每个派生对象重新创建它们：
```
public class ParentClass
{
    public int MyId {get; set;}
    public static string CommonField1 {get; set;}
    public static string CommonField2 {get; set;}
    public static string CommonField3 {get; set;}
    public string Changeable {get; set;}
```
请注意，其中一些应该是protected而不是public，您应该始终通过属性而不是直接公开公共字段。当然，如果您有多个ParentClass个实例，这些实例具有不同的值，那么这是不行的。

Answer 2

如果孩子和父母应该有一些关系（即共享方法/属性的公共父类），但是孩子需要与父母共享属性，你可以将属性请求重定向到父母（请注意，男人会获得深层嵌套孩子的属性）很慢）：

public class Node
{
    public virtual string Field {get {return parent != null ? parent.Field : field;}}

    public Node parent;
    public List<Node> children;

    public Node()
    {
        children = new List<Node>();
    }

    public createChildren()
    {
        for(int i = 0; i < 999999; i++) 
        {
            children.Add(new ChildNode(i, this));
        }
    }
}

public class ChildNode : Node
{
    public override string Field {get {return parent.Field;}}
    public ChildNode(Node parent)
    {
        this.parent = parent;
    }
}

public class RootNode : Node
{
    public override string Field {get {return "Root";}}
    public RootNode()
    {
        this.parent = null;
    }
}

继承的类引用基类＆＃39;值

2 个答案: