C#中的静态成员继承，最好的方法是什么？

Question

解决这个问题的最佳方法是什么？

静态成员是所有子类的成员，我希望子类使用不同的静态成员，但名称相同，这样我就可以使用 vehicle.canDo；这应该给我不同的数组，具体取决于车辆实例的真正类别。

我可以从 canDo 数组中删除静态，但是同一子类的所有实例在 canDo 数组中应该始终具有相同的值，因此不需要在每个实例中都有 canDo 数组，这将浪费大量内存，因为我会有太多此类的实例。

class Vehicle {
    public static List<string> canDo;

    static Vehicle() {
        canDo = new List<string>(); 
        canDo.Add("go");
    }
}

class Plane : Vehicle {
    static Plane() {
        canDo.Add("fly");
    }
}

class Ship : Vehicle {
    static Ship() {
        canDo.Add("sail");
    }
}



class Main {
    static void Main(string[] args) {
        Vehicle plane = new Plane();
        Vehicle ship = new Ship();

        plane.canDo; // Contains (go, fly and sail) i want only (go and fly)
        ship.canDo; // Contains (go, fly and sail) i want only (go and sail)
    }
}

Answer 1

解决这个问题的最佳方法是什么？

不要对非静态的事物滥用静态方法。就这么简单。

静态没有继承，也不是可以以任何方式具有继承场景的东西。

您正在通过滥用一项功能进行战斗 - 不值得战斗。请学习正确的面向对象。

Answer 2

请注意，您还可以使用 new 隐藏基类的 canDo：

class Vehicle
{
    public static List<string> canDo = new List<string>() { "go" };   
}

class Plane : Vehicle
{
    public new static List<string> canDo = new List<string>(Vehicle.canDo);
    static Plane()
    {
        canDo.Add("fly");
    }
}

Answer 3

你不需要静态变量和构造函数，只需添加基本构造函数（默认完成，: base() 是可选的）：

class Vehicle {
    public List<string> canDo;

    Vehicle() {
        canDo = new List<string>(); 
        canDo.Add("go");
    }
}

class Plane : Vehicle {
    Plane() : base() {
        canDo.Add("fly");
    }
}

class Ship : Vehicle {
    Ship() : base() {
        canDo.Add("sail");
    }
}

更新：基于@Eben Roux 的评论 -

public abstract class Vehicle {
    protected static List<string> _canDo;
    protected abstract List<string> getCanDo();
    public List<string> canDo{
        { get {
               var _cando = new List();
               _cando.AddRange(Vehicle._canDo);
               _cando.AddRange(this.getCanDo());
               return _cando;
              }
        }
    }
    static Vehicle() {
        _canDo = new List<string>(); 
        _canDo.Add("go");
    }
}

class Ship : Vehicle {
    protected static List<string> childCanDo;
    protected override getCanDo(){
        return Ship.childCanDo;
    }
    static Ship() {
        childCanDo.Add("sail");
    }
}

Answer 4

您需要每个类型的canDo 列表的实例。因此，您可以通过构造函数传入集合，也可以在子类型级别使用静态。

编辑（详细说明）：

由于您的子类实例都具有相同的“能力”，并且您不想为每个都填充一个列表，因此您需要一个共享列表。您在可能需要组合的地方使用继承：

public abstract class Vehicle
{
    protected List<string> canDo;

    protected Vehicle(List<string> canDo)
    {
        this.canDo = canDo;
    }
}

public class Plane : Vehicle
{
    public Plane(List<string> canDo) : base(canDo)
    {
    }
}

我也不会使用List<string>，而是将其封装在一个具有商业意义的类中（尽管我知道这只是一个示例）。要填充 canDo 列表，您可以使用工厂或子类型上的工厂方法。

有很多方法可以做到这一点，您需要找到舒适的东西。

虽然我确实提出了一个静态作为替代方案（因为你在问它），但我自己绝对不会为此使用静态。