协助在 C# 中设置类和对象 [关闭]

Question

肯定仍然是一名正在接受培训的程序员，但正试图为我的项目做点什么，并绕着圈子转。请在设置我的课程时寻求任何指导。我正在开发代码供其他人通过 .dll 程序集使用。

让我只描述一个简单的类（使用 Base 类），名为 Car，它有一些属性。这些就是我想要达到的要求：

1) 创建 Car 类实例的能力。用户实例化的 Car 对象的所有属性都应该是可变的。

2) 能够为他们提供 3 个预生成的 Car 对象供他们直接使用。怎么样：本田 CRV、丰田普锐斯、日产 Rogue

3) 预先生成的汽车（Honda CRV、Toyota Prius、Nissan Rogue）应该被锁定（只读？）。甚至 Base 类 Transport 中的属性也应该是只读的。

实现这一目标的最佳方法是什么？我是否使用静态属性？我是否使用 readonly 修饰符？我是否创建了一个名为 HondaCRV 的新类（例如）并使用 Car 作为基类？然后让东西在那里只读？我将什么设为公开和私有（或受保护）？还是我只是创建一个名为“Cars”的新类，它公开了我的 3 个预先生成的汽车（作为属性）而没有别的？

我只是不知道什么是最好的方法，哪种方法可以为我的组装消费者提供最佳体验。我尝试了一些事情并且接近了，但我永远无法让“只读”传播到基类。

请原谅我在示例代码中可能写的任何不良做法。我仍然是一名正在接受培训的 C# 程序员。

提前感谢您为我提供的任何帮助并尝试理解我的帖子。我很高兴（也很兴奋）学习并采纳您对我的任何想法。我也很乐意澄清任何事情。我尽力表达了我的要求。

阿马尔

enum Terrain
{
    Land,
    Water,
    Air
}

class Transportation
{
    private Terrain terrainType;

    public Terrain TerrainType
    {
        get { return terrainType; }
        set { terrainType = value; }
    }
}

class Car:Transportation
{
    private string mfg;
    private string model;

    public string Mfg
    {
        get { return mfg; }
        set { mfg = value; }
    }

    public string Model
    {
        get { return model; }
        set { model = value; }
    }

    public Car(string Manufacturer, string CarModel)
    {
        Mfg = Manufacturer;
        Model = CarModel;
        TerrainType = Terrain.Land;
    }
}

Answer 1

这就是我要做的。在现实生活中，我可能在数据库中有一个Manufacturer 表和一个Model 表，它们之间存在外键关系。在这里，我使用enum 和Dictionary 对其进行建模

我将枚举用于制造商。这是一个不会经常更改的列表（在过去十年左右的时间里，我可以将 Genesis 和 Tesla 视为新制造商）：

public enum CarManufacturer
{
    Acura,
    BMW,
    Buick,
    //fill in more
    Honda,
    Nissan,
    Tesla,
    Toyota,
    //etc
}

我留下了你的“地形”枚举：

public enum Terrain
{
    Land,
    Water,
    Air
}

我将您的 Transportation 类更改为 abstract（即不可实例化）并将 TerrainType 属性设为只读。只能在构造函数中设置。我还只提供了一个非默认构造函数（因此必须设置该属性）：

//This is abstract, no one can instantiate one, 
//only subclasses of this type can be constructed
public abstract class Transportation
{
    //this is read-only and must be set at construction time
    public Terrain TerrainType { get; }

    protected Transportation(Terrain terrainType)
    {
        TerrainType = terrainType;
    }

    //you probably want some methods (example, Move).  You can declare them "abstract"
}

对汽车类的大量更改：

• 我制作了一个私有（静态）制造商字典 模型关系。
• 我提供对该字典的有限访问（客户可以获得模型列表，并可以验证特定模型是否由制造商制造）
• 我将 Manufacturer 和 Model 属性设为只读 - 它们都必须在构建时设置
• 我让（唯一的）构造函数设置了这些属性，并酌情调用了非默认的 Transportation 构造函数

结果如下：

public class Car : Transportation
{
    //in real life, this might be stored in a database
    private static readonly Dictionary<CarManufacturer, List<string>> CarModels =
        new Dictionary<CarManufacturer, List<string>>
        {
            {CarManufacturer.Acura, new List<string> {"RDX", "NSX", "MDX",}},
            {CarManufacturer.BMW, new List<string> {"2Series", "3Series", "etc",}},
            {CarManufacturer.Honda, new List<string> {"Civic", "Fit", "CRV", "Pilot",}},
            {CarManufacturer.Nissan, new List<string> {"Altima", "Maxima", "Rogue",}},
            {CarManufacturer.Toyota, new List<string> {"Corolla", "Prius",}},
        };

    //these get set at constructor time, they cannot be changed after that
    public CarManufacturer Manufacturer { get; }
    public string Model { get; }

    //you need to call the parameterized base class constructor
    public Car(CarManufacturer manufacturer, string model) : base(Terrain.Land)
    {
        Manufacturer = manufacturer;
        if (!ValidateCarModel(manufacturer, model))
        {
            throw new ArgumentException($"Manufacturer {manufacturer} does not make model: {model}");
        }
        Model = model;
    }

    public static bool ValidateCarModel(CarManufacturer manufacturer, string model)
    {
        if (!CarModels.TryGetValue(manufacturer, out var models))
        {
            return false;
        }

        return models.Contains(model);
    }

    public static IEnumerable<string> ModelsForManufacturer(CarManufacturer manufacturer)
    {
        if (!CarModels.TryGetValue(manufacturer, out var models))
        {
            //maybe this should through, but this also makes sense
            return new List<string>();
        }
        //otherwise
        return models;
    }
}

现在我可以制作一些汽车了。我可以在创建它们之前测试它们是否有效（或无效）：

 Car CRV, Rogue, Prius;
 if (Car.ValidateCarModel(CarManufacturer.Honda, "CRV"))
 {
     CRV = new Car(CarManufacturer.Honda, "CRV");
 }
 if (Car.ValidateCarModel(CarManufacturer.Nissan, "Rogue"))
 {
     Rogue = new Car(CarManufacturer.Nissan, "Rogue");
 }
 //I know that Toyota makes a Prius, so I just create one.  If I mess up, I'll get an exception
 Prius = new Car(CarManufacturer.Toyota, "Prius");

我认为这符合你的需求，而且有点指导意义

请注意，除了制造商枚举之外，如果我使用数据库而不是枚举/字典方法来完成此操作，我可以拥有大致相同的界面。

Answer 2

为他们提供 3 个预先生成的 Car 对象，让他们开箱即可使用

只添加几个类的实例怎么样？

class Car
{
    ...

    public static readonly List<Car> Instances = new List<Car>() 
    {
        new Car() {Model = "Honda", Name = "CRV"}, 
        new Car() {Model = "Toyota", Name = "Prius"}, 
        new Car() {Model = "Nissan", Name = "Rogue"}
    };
}

他们可以像这样访问它们：

Car car = Car.Instances[0];

Answer 3

我不知道在一个类中做你想做的事情的直接方法，但你可以使用模式组合作为解决方法：不可变和工厂。

首先，您声明 ImmutableCar 类，它隐藏了这样的基类设置器。

public class ImmutableCar : Car
{
    public string Mfg
    {
        get { return base.Mfg; }
    }

    public string Model
    {
        get { return base.Model; }
    }

    public Terrain TerrainType
    {
        get { return base.TerrainType; }
    }

    internal ImmutableCar(string Manufacturer, string CarModel) : base (Manufacturer, CarModel)
    {
    }
}

其次，您将 Car 和 ImmutableCar 类的所有构造函数都设置为内部，因此您的程序集的用户无法调用它。

internal Car(string Manufacturer, string CarModel)
{
    Mfg = Manufacturer;
    Model = CarModel;
    TerrainType = Terrain.Land;
}

internal ImmutableCar(string Manufacturer, string CarModel) : base (Manufacturer, CarModel)
{
}

第三，创建工厂类，实例化所有汽车。它通过属性返回 ImmutableCar 提供您的“只读”汽车。对于可编辑的汽车，它提供了 GenerateCar 方法。

public static class CarFactory
{
    public static ImmutableCar HondaCrv { 
        get
        {
            return new ImmutableCar("Honda", "Crv");
        }
    }

    public static Car GenerateCar(string Manufacturer, string CarModel)
    {
        return new Car(Manufacturer, CarModel);
    }
}

最后进行一些测试。

        var landroverDiscovery = CarFactory.GenerateCar("Land Rover", "Discovery 2");
        landroverDiscovery.Model = "test"; // Ok
        var hondaCrv = CarFactory.HondaCrv;
        hondaCrv.Model = "test"; // Produces error