如何用.NET驱动在MongoDB中聚合替换数据及解决Lookup问题

我来帮你一步步解决这两个MongoDB .NET驱动的问题～

一、数据聚合操作 #

咱们先从聚合说起，.NET驱动通过IMongoCollection<T>.Aggregate()方法来构建聚合管道，常用的聚合阶段（比如过滤、分组、排序）都有对应的强类型API，上手很方便：

举个实际例子，比如统计不同价格区间的产品数量：

var productCollection = mongoDatabase.GetCollection<Product>("Products");

var aggregationResult = productCollection.Aggregate()
    // 先过滤掉价格无效的产品
    .Match(p => p.Price > 0)
    // 按价格区间分组，统计每组的产品数量
    .Group(
        p => new { PriceRange = p.Price switch {
            <= 100 => "低价",
            <= 500 => "中价",
            _ => "高价"
        } },
        g => new { PriceRange = g.Key.PriceRange, ProductCount = g.Count() }
    )
    // 按数量从多到少排序
    .SortByDescending(r => r.ProductCount)
    .ToList();

如果需要用MongoDB原生的聚合操作符（比如一些复杂的字段计算），可以用AppendStage直接传入BsonDocument来实现自定义阶段：

// 新增一个折扣价字段，原价打8折
var addDiscountStage = new BsonDocument(
    "$addFields", 
    new BsonDocument("DiscountPrice", new BsonDocument("$multiply", new BsonArray { "$Price", 0.8 }))
);

// 定义一个带折扣价的实体类接收结果
public class ProductWithDiscount : Product {
    public double DiscountPrice { get; set; }
}

var result = productCollection.Aggregate()
    .AppendStage<ProductWithDiscount>(addDiscountStage)
    .ToList();

二、替换操作 #

替换操作分两种常见场景：

1. 替换单条文档：用ReplaceOne方法，根据过滤条件匹配文档后，用新文档完全替换它

var filter = Builders<Product>.Filter.Eq(p => p.Id, "prod_001");
var updatedProduct = new Product { Id = "prod_001", Name = "新款无线耳机", Price = 299.99 };

// IsUpsert设为true的话，如果没匹配到文档，会直接插入这条新文档
var replaceResult = productCollection.ReplaceOne(filter, updatedProduct, new ReplaceOptions { IsUpsert = true });

2. 聚合中替换根文档：如果聚合输出的结构需要和原实体不同，可以用ReplaceWith（或旧版本的ReplaceRoot）来替换输出的根结构：

var simplifiedResult = productCollection.Aggregate()
    .Match(p => p.Price > 200)
    // 只输出产品名和折后价（打9折）
    .ReplaceWith(p => new { ProductName = p.Name, DiscountedPrice = p.Price * 0.9 })
    .ToList();

从你给出的实体类来看，问题肯定出在**Order里的OrderProducts是数组类型**——直接用普通的$lookup没法正确关联数组里的每个ProductId到Product集合。下面给你两种可行的解决方案：

方案1：用$unwind拆分数组 + $lookup关联 + $group重组订单 #

先把OrderProducts数组拆成单个文档，关联产品后再重新分组回原来的订单结构：

var orderCollection = mongoDatabase.GetCollection<Order>("Orders");
var productCollection = mongoDatabase.GetCollection<Product>("Products");

var aggregatedOrders = orderCollection.Aggregate()
    // 把每个Order的OrderProducts数组拆成独立文档，每个文档对应一个OrderProduct
    .Unwind(o => o.OrderProducts)
    // 关联Product集合：用OrderProducts.ProductId匹配Product.Id
    .Lookup(
        foreignCollection: productCollection,
        localField: "OrderProducts.ProductId",
        foreignField: "Id",
        @as: "MatchedProduct"
    )
    // 把关联得到的MatchedProduct数组转为单个对象（因为每个OrderProduct只对应一个Product）
    .Unwind("MatchedProduct")
    // 按Order.Id重新分组，重组订单的完整结构
    .Group(
        key => key.Id,
        g => new {
            OrderId = g.Key,
            TotalAmount = g.First().Total,
            ProductsInOrder = g.Select(item => new {
                ProductId = item.OrderProducts.ProductId,
                Quantity = item.OrderProducts.Quantity,
                ProductInfo = item.MatchedProduct
            }).ToList()
        }
    )
    .ToList();

方案2：用$lookup的子管道（更高效，无需拆分数组） #

.NET驱动支持Lookup的重载方法，通过自定义子管道来匹配数组中的每个ProductId，不用先拆分数组，性能更好：

// 先定义两个辅助类，用来接收关联后的结果
public class OrderProductWithProductInfo : OrderProduct {
    public Product Product { get; set; }
}

public class OrderWithFullProductInfo : Order {
    public new List<OrderProductWithProductInfo> OrderProducts { get; set; }
}

var orderCollection = mongoDatabase.GetCollection<Order>("Orders");
var productCollection = mongoDatabase.GetCollection<Product>("Products");

var result = orderCollection.Aggregate()
    .Lookup<Order, Product, OrderWithFullProductInfo>(
        productCollection,
        // 把当前订单的所有ProductId传递给子管道
        order => order.OrderProducts.Select(op => op.ProductId),
        product => product.Id,
        // 自定义关联逻辑：把每个OrderProduct和对应的Product绑定
        (orders, products) => orders.Select(order => new OrderWithFullProductInfo {
            Id = order.Id,
            Total = order.Total,
            OrderProducts = order.OrderProducts.Select(op => new OrderProductWithProductInfo {
                ProductId = op.ProductId,
                Quantity = op.Quantity,
                Product = products.FirstOrDefault(p => p.Id == op.ProductId)
            }).ToList()
        })
    )
    .ToList();

为啥你的原实现不行？ #

如果直接用普通Lookup，把localField设为OrderProducts.ProductId，MongoDB会把整个ProductId数组当成一个值，去匹配Product集合里的单个Id字段，自然匹配不到任何数据。所以必须要么拆分数组逐个关联，要么用子管道来处理数组内的每个元素。

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