组合在 C# 中是如何工作的？

Question

我有一个汽车课：

public class Car
{    
    private String _Brand;
    private String _Model;
    private Engine _Engine;

    public Car(){

    }

     public String Brand
     {
        get { return _Brand; }
        set { _Brand = value; }
     }

     public String Model
     {
        get { return _Model; }
        set { _Model = value; }
     }

     public Engine Engine
     {
        get { return _Engine; }
        set { _Engine = value; }
     }
}

还有一个引擎类：

public class Engine
{
     private int _Code;
     private DateTime _Year;

     public Engine(){

     }

     public int Code
     {
        get { return _Code; }
        set { _Code = value; }
     }

     public DateTime Year
     {
        get { return _Year; }
        set { _Year = value; }
     }
}

从 Registration.aspx.cs 的代码隐藏中，我想使用按钮、汽车和引擎以及它们各自的关系（组合）来创建。

但是，我对这些对象的合成应该如何表现有很大的困惑。即，我不知道是否必须在 Car 的构造函数中声明：Engine = new Engine();，或者是否在注册事件（按钮，代码隐藏）中声明：Car car = new Car()，然后是 car.Engine = new Engine();。

我不知道在这样的场景中组合关系是如何工作的。声明“new”的位置的存在让我陷入了各种概念的混杂。

问候

Answer 1

你可以像下面这样重构你的类，以避免boilerplate code。我们只是使用了一个名为自动实现属性的功能。

public class Engine
{
    public int Code { get; set; }
    public DateTime Year { get; set; }
}

public class Car
{    
    public string Brand { get; set; }
    public string Model { get; set; }
    public Engine Engine {get; set; } 
}

现在请注意删除了多少行代码。

关于您的问题，您可以使用 object initializer 创建一个 Car 类型的对象，如下所示：

var car = new Car 
{
    Brand = "the brand name";
    Model = "the model name";
    Engine = new Engine
    {
        Code = "the code engine";
        Year = new DateTime(2017,1,1); // the year the engine manufactured.
    }
}

我建议您阅读这两个特性，自动实现的属性和对象初始化器。下面有两个关于这些功能的链接。

• Auto-Implemented Properties
• Object and Collection Initializers

Answer 2

这完全取决于您设计课程的方式。汽车和发动机非常通用。例如，如果您要创建一辆 Mercedes，那么创建一个继承自 Car 的新类型 MercedesCar 是有意义的。在这种情况下，您可以在 MercedesCar 的构造函数中实例化一个 MercedesEngine，如下所示：

public class Car
{
    public Engine Engine
    {
        get;
        private set;
    }

    public Car(Engine engine)
    {
        this.Engine = engine;
    }
}

public class MercedesCar : Car
{
    public MercedesCar() : base(new MercedesEngine())
    {
    }
}

public class Engine
{
}

public class MercedesEngine : Engine
{
}

但如果你只坚持使用Car类，那么从外部创建引擎并没有错！

Answer 3

这取决于您希望如何控制 Engine 属性的可访问性/使用。

案例 1： 如果您希望 Car 完全控制 Engine 属性并且没有其他人可以访问它，请将其设为私有字段并在 Car 构造函数中实例化。

public class Car
{
    private readonly Engine _engine;
    public Car()
    {
        _engine = new Engine();
    }               
}

案例 2： 引擎应该可以从外部访问，以便任何人都可以设置或访问它。 它可以通过两种方式完成：

1) 构造函数注入 - 通过构造函数注入依赖，通常使用接口抽象，以便轻松完成模拟/单元测试。

public class Car
{
    public Car(IEngine engine)
    {
        Engine = engine;
    }
    public IEngine Engine { get; set; }
}
var car = new Car(new Engine());

2) 手动设置引擎属性

public class Car
 {  
    public Engine Engine { get; set; }           
 }
var car = new Car();
car.Engine = new Engine();

Answer 4

我已经讨论了这个级别的类架构已经有几年了，所以我会尽量不让自己听起来很愚蠢:)

首先，我不认为我们在这里谈论组合：（在现实生活中）Engine 的生命周期不受Car 的约束/控制。如果我假设正确，那么这两个类都试图代表现实生活的映射。

据我所知，实际上，您可以购买 Engine 到 Car，但如果没有 Engine，Car 将无法运行（但可以存在）（可能是那些新奇的特斯拉可以吗？）。

那尖叫不是作曲，因为它没有描述所有权关系。

根据您想要的严格程度，我将其称为聚合（更多）或关联（更少）。

我个人更倾向于聚合，因为它比Car 和Spoiler 更牢固。

因此，我的建议是：

C#

public class Engine
{
     public Engine() { ... }     

     public int Code { get; set; }

     public DateTime Year { get; set; }
}

public class Car
{
     public Car(Engine engine) : this() { 
          this.Engine = engine;
     }

     public Car() {
     } 

     public string Brand { get; set; }

     public String Model { get; set; }

     public Engine Engine { get; set; }
}

代码隐藏

var engine = new Engine();
var car = new Car(engine);

Car 类定义是说您可以创建带有或不带有 Engine 的 Car，但对我来说，它强调了 Engine 对 Car 确实很重要，因此构造函数接受Engine 可用。

关于作曲

Car 是“整体”和Engine 是“部分”的组合意味着Engine 生命周期完全由Car 控制。在这种情况下，您基本上是在声明“在创建 Car 的新对象时，该对象将在内部创建一个新的 Engine，该 Engine 将在不再使用 Car 对象时被释放。”

代码如下所示：

//still the same
public class Engine
{
     public Engine() { ... }     

     public int Code { get; set; }

     public DateTime Year { get; set; }
}

public class Car
{
     public Car() {
        //_engine = new Engine();
     }

     //Engine initialisation can be either here or inside the constructor (check constructor's commented code)
     private readonly Engine _engine = new Engine();

     public string Brand { get; set; }

     public String Model { get; set; }

     //you shouldn't be able to assign an _engine from outside
     public Engine Engine { get { return _engine; } }
}

组合代码隐藏

var car = new Car();
car.Engine.Code = 123;