Question

假设我有一堂课：

public class Parent
{
    public string Name { get; set; }
    public string City { get; set; }
}

并且在某些函数中我得到对象列表类型为Parent，接下来我想用新字段扩展那些带有一些值的对象，所以我要声明一个像这样的扩展类：

public class Child : Parent
{
    public Child(Parent parent)
    {
        Name = parent.Name;
        City = parent.City;
    }
    public int Age { get; set; }
}

并为每个扩展对象调用costructor。有没有更好的方法呢？如果Parent中有多个属性怎么办？也许还有一些更优雅的方法来实现这一目标？

Answer 1

我想也许你正在寻找一个复制构造函数模式。每个级别定义一个protected构造函数，用于复制相关属性：

public class Parent
{
    public string Name { get; set; }
    public string City { get; set; }

    //normal constructor
    public Parent()
    {

    }

    protected Parent(Parent copy)
    {
        this.Name = copy.Name;
        this.City = copy.City;
    }
}

Child将继承自Parent，将其传递给复制构造函数，然后根据需要附加其新值：

public class Child : Parent
{
    public string NewInfo { get; set; }

    public Child(Parent copy)
        : base(copy)
    {

    }
}

用法可能如下：

Parent parent = new Parent() { Name = "Name", City = "StackOverflow"};

Child child = new Child(parent) { NewInfo = "Something new!" };

Console.WriteLine(child.Name); //Name
Console.WriteLine(child.City); //StackOverflow
Console.WriteLine(child.NewInfo); //Something new!

这样做的好处是，您可以拥有多个级别的继承，每个级别都可以管理自己的属性。

编辑：鉴于您最近的评论：

这个问题的动机是我获得的问题带有数据的对象列表，并希望显示此数据但有一些其他字段，不触及基类。

也许更好的方法是包装基类：

public class Child
{
    private readonly Parent WrappedParent;

    public string NewInfo { get; set; }

    public string Name 
    { 
        get { return WrappedParent.Name; }
        set { WrappedParent.Name = value; }
    }

    public string City 
    { 
        get { return WrappedParent.City; }
        set { WrappedParent.City = value; }
    }

    public Child(Parent wrappedParent)
    {
        this.WrappedParent = wrappedParent; 
    }
}

下行是你必须重新声明每个属性，并且你不再继承（不能被认为是）"Parent"，但是你绝对是＆＃34;没有触及＆＃34;基类了。可以移动＆＃34;父母＆＃34;属性为IParent界面，如果这对您更好，但再次这样做是＆＃34;触摸＆＃34;基类，因为您必须将IParent接口声明添加到其类定义中。

Answer 2

不确定我是否错了，但这可能是一个更标准的解决方案

public class Parent
{
    public Parent(string name, string city)
    {
       Name = name;
       City = city;
    }

    public string Name { get; set; }
    public string City { get; set; }
}

public class Child : Parent
{
    public Child(string name, string city, int age) : base(name, city)
    {
       Age = age;
    }
    public int Age { get; set; }
}

Answer 3

你可以这样做

public class Parent
{
    public string Name { get; set; }
    public string City { get; set; }

    public Parent(string name, string city)
    {
        this.Name = name;
        this.City = city;
    }

    public Parent():this(string.Empty, string.Empty)
    {
    }
}

public class Child : Parent
{
    public Child(Parent parent, int age):base(parent.Name, parent.City)
    {
        this.Age = age;
    }

    public int Age { get; set; }
}

使用父值中的值扩展对象

3 个答案: