如何在对象初始化器中传递父对象构造属性给嵌套对象构造函数？

场景与问题 #

现有三个关联类Car、Part、Tool的定义如下：

Car类 #

public class Car 
{
  public Guid ManufacturerId { get; set; }
  public Guid CarId { get; set; }
  public List<Part> Parts { get; set; }
  // 其他属性如Name等

  public Car(Guid manufacturerId)
  {
    ManufacturerId = manufacturerId;
    CarId = Guid.NewGuid();
    Parts = new List<Part>();
  }
}

Part类 #

public class Part
{
  public Guid PartId { get; set; }
  public Guid CarId { get; set; }
  public List<Tool> Tools { get; set; }
  // 其他属性如Name等

  public Part(Guid carId)
  {
    CarId = carId;
    PartId = Guid.NewGuid();
    Tools = new List<Tool>();
  }
}

Tool类 #

public class Tool
{
  public Guid ToolId { get; set; }
  public Guid PartId { get; set; }
  // 其他属性如Name等

  public Tool(Guid partId)
  {
    PartId = partId;
    ToolId = Guid.NewGuid();    
  } 
}

现在希望用单语句的对象初始化器创建Car实例，同时把Car构造函数中自动生成的CarId传递给嵌套的Part构造参数，无需提前在全局定义参数值，比如期望的写法类似：

var car = new Car(Guid.NewGuid())
{
  Parts = new List<Part>()
    {
      new Part(...这里插入构造好的car.CarId...) 
        {...配置Part属性...},

      new Part(...这里插入构造好的car.CarId...)
        {...配置Part属性... },
    }
};

但这种写法是否可行？如果不行，有哪些替代方案？

核心结论 #

直接按上述期望写法是无法实现的。原因是C#的执行顺序：

1. 先调用new Car(Guid.NewGuid())执行构造函数，生成CarId并创建Car对象
2. 才会执行对象初始化器中的Parts = ...逻辑
3. 在初始化Parts的阶段，car变量还未完成赋值（对象初始化完成后才会把实例赋值给car），因此无法在new Part()的参数中引用car.CarId，编译器会抛出“使用了未赋值的局部变量”错误。

可行替代方案 #

方案1：给Car类添加便捷的AddPart方法 #

修改Car类，增加一个用于添加Part的方法，内部自动传递当前Car的CarId，支持链式调用：

public class Car 
{
    // 原有代码不变...

    public Car AddPart(Action<Part> configurePart = null)
    {
        var part = new Part(this.CarId);
        // 允许配置Part的其他属性
        configurePart?.Invoke(part);
        this.Parts.Add(part);
        return this;
    }
}

使用方式：

var car = new Car(Guid.NewGuid())
    .AddPart(p => 
    { 
        p.Name = "引擎";
        // 还可以继续添加Tool
        p.Tools.Add(new Tool(p.PartId) { Name = "扳手" });
    })
    .AddPart(p => 
    { 
        p.Name = "轮胎";
    });

方案2：拆分创建与初始化步骤 #

先创建Car实例，再初始化Parts集合，此时car变量已赋值，可以直接引用CarId：

var car = new Car(Guid.NewGuid());
car.Parts = new List<Part>
{
    new Part(car.CarId) { Name = "引擎" },
    new Part(car.CarId) { Name = "轮胎" }
};

这种方式简单直观，无需修改原有类结构，只是多了一行代码。

方案3：使用工厂方法封装创建逻辑 #

如果需要频繁创建带Parts的Car，可以封装一个工厂类，把创建逻辑集中管理：

public static class CarFactory
{
    public static Car CreateCar(Guid manufacturerId, params Action<Part>[] partConfigs)
    {
        var car = new Car(manufacturerId);
        foreach (var config in partConfigs)
        {
            var part = new Part(car.CarId);
            config(part);
            car.Parts.Add(part);
        }
        return car;
    }
}

使用方式：

var car = CarFactory.CreateCar(Guid.NewGuid(),
    p => 
    {
        p.Name = "引擎";
        p.Tools.Add(new Tool(p.PartId) { Name = "螺丝刀" });
    },
    p => 
    {
        p.Name = "变速箱";
    });

内容的提问来源于stack exchange，提问作者Joseph Hutton