如何用LINQ创建引用父级的不可变嵌套对象图

这确实是不可变对象与LINQ结合时的一个典型卡点——LINQ的声明式语法更偏向一次性构造对象，但父-子的循环引用要求我们必须先拿到父对象的引用，才能创建正确的子对象。下面给你几个完全符合不可变设计原则的解决方案：

方案1：在LINQ的Lambda代码块中分两步构造 #

我们可以先创建一个临时的父对象（Invoice），再用这个临时对象作为引用创建子对象（Item），最后生成完整的不可变Invoice：

void Main() {
    var nums = new[]{ 
        new { inv = 1, lineitems =new [] {new { qty = 1, sku = "a" }, new { qty = 2, sku = "b" }}}, 
        new { inv = 2, lineitems =new [] { new { qty = 3, sku = "c" }, new { qty = 4, sku = "d" }}}, 
        new { inv = 3, lineitems =new [] { new { qty = 5, sku = "e" }, new { qty = 5, sku = "f" }}} 
    }; 

    var invoices = nums.Select(i => {
        // 1. 先创建临时Invoice，Items暂时为空
        var tempInvoice = new Invoice(i.inv, Enumerable.Empty<Item>());
        // 2. 用临时Invoice作为父引用创建所有Item
        var items = i.lineitems.Select(l => new Item(l.qty, l.sku, tempInvoice));
        // 3. 创建最终的完整Invoice，传入正确的Items集合
        return new Invoice(i.inv, items);
    }); 

    invoices.Dump(); 
} 

public class Invoice {
    public int Number { get; }
    public IEnumerable<Item> Items { get; }

    public Invoice(int number, IEnumerable<Item> items) {
        Number = number;
        // 可选：将Items转换为只读集合，进一步强化不可变性
        Items = items.ToList().AsReadOnly();
    }
} 

public class Item {
    public Invoice Parent { get; }
    public int Qty { get; }
    public string SKU { get; }

    public Item(int qty, string sku, Invoice parent) {
        Parent = parent;
        Qty = qty;
        SKU = sku;
    }
}

这个方案的核心是利用Lambda的代码块特性，分阶段完成对象构造，但全程保持不可变性——所有对象一旦创建就不会被修改，完全符合你的设计目标。

方案2：用静态工厂方法封装构造逻辑（更优雅） #

把复杂的父-子构造逻辑封装到Invoice的静态工厂方法中，外部代码可以保持简洁的LINQ调用，同时隐藏内部的临时对象细节：

void Main() {
    var nums = new[]{ 
        new { inv = 1, lineitems =new [] {new { qty = 1, sku = "a" }, new { qty = 2, sku = "b" }}}, 
        new { inv = 2, lineitems =new [] { new { qty = 3, sku = "c" }, new { qty = 4, sku = "d" }}}, 
        new { inv = 3, lineitems =new [] { new { qty = 5, sku = "e" }, new { qty = 5, sku = "f" }}} 
    }; 

    // LINQ调用变得非常简洁
    var invoices = nums.Select(i => Invoice.Create(i.inv, i.lineitems.Select(l => (l.qty, l.sku)))); 

    invoices.Dump(); 
} 

public class Invoice {
    public int Number { get; }
    public IReadOnlyCollection<Item> Items { get; }

    // 私有构造函数，强制通过工厂方法创建实例
    private Invoice(int number, IReadOnlyCollection<Item> items) {
        Number = number;
        Items = items;
    }

    public static Invoice Create(int number, IEnumerable<(int Qty, string Sku)> lineItems) {
        // 内部临时构造Invoice，用于给Item提供父引用
        var tempInvoice = new Invoice(number, Array.Empty<Item>());
        // 创建Item并转换为只读集合
        var items = lineItems.Select(l => new Item(l.Qty, l.Sku, tempInvoice))
                             .ToList()
                             .AsReadOnly();
        // 返回最终的完整Invoice
        return new Invoice(number, items);
    }
} 

public class Item {
    public Invoice Parent { get; }
    public int Qty { get; }
    public string SKU { get; }

    public Item(int qty, string sku, Invoice parent) {
        Parent = parent;
        Qty = qty;
        SKU = sku;
    }
}

这个方案的优势在于关注点分离：外部代码不需要知道父-子对象的构造细节，只需要调用工厂方法即可；同时通过私有构造函数，进一步保证了Invoice的不可变性——外部无法随意创建不完整的Invoice实例。

可选优化：重新评估Parent引用的必要性 #

如果业务场景允许，你可以考虑是否真的需要Item持有Invoice的强引用。比如，只在Item中保存Invoice的Number，后续需要关联时通过Number查找对应的Invoice，这样可以完全避免循环引用的问题，让不可变对象的创建变得更简单。当然，这取决于你的具体业务需求。

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