这似乎是一个复杂而冗长的查询。

1. $lookup-加入“证券”集合并返回Securities数组。
2. $lookup-加入“MutualFunds”集合并返回Mfs数组。
3. $set -
   3.1.设置Securities字段，通过将每个对象与Stocks数组中的对象合并来执行Map。
   3.2.将Mfs字段设置为通过将每个对象与MutualFunds数组中的对象合并来执行Map。
4. $unset-删除不需要的字段。

db.Portfolio.aggregate([
  {
    "$lookup": {
      "from": "Securities",
      "localField": "Stocks.StockId",
      "foreignField": "StockId",
      "as": "Securities"
    }
  },
  {
    "$lookup": {
      "from": "MutualFunds",
      "localField": "MutualFunds.MutualFundId",
      "foreignField": "MfId",
      "as": "Mfs"
    }
  },
  {
    $set: {
      "Securities": {
        $map: {
          input: "$Securities",
          as: "s",
          in: {
            $mergeObjects: [
              "$$s",
              {
                $first: {
                  $filter: {
                    input: "$Stocks",
                    cond: {
                      $eq: [
                        "$$s.StockId",
                        "$$this.StockId"
                      ]
                    }
                  }
                }
              }
            ]
          }
        }
      },
      "Mfs": {
        $map: {
          input: "$Mfs",
          as: "m",
          in: {
            $mergeObjects: [
              "$$m",
              {
                $first: {
                  $filter: {
                    input: "$MutualFunds",
                    cond: {
                      $eq: [
                        "$$m.MutualFundId",
                        "$$this.MfId"
                      ]
                    }
                  }
                }
              }
            ]
          }
        }
      }
    }
  },
  {
    $unset: [
      "Stocks",
      "MutualFunds",
      "Securities._id",
      "Mfs._id",
      "Mfs.MutualFundId"
    ]
  }
])

Demo @ Mongo Playground
使用MongoDB Compass，它允许export the aggregation pipeline into a specific language。您可以在C#中使用BsonDocument来处理查询。
1.构造输出模型类。

[BsonNoId]
[BsonIgnoreExtraElements]
public class PortfolioOutputModel
{
    public string Name { get; set; }
    public List<Security> Securities { get; set; }
    public List<MutualFund> Mfs { get; set; }
}

public class Security
{
    public long StockId { get; set;}
    public string Name { get; set;}
    public decimal LastPrice { get; set;}
    public decimal LastPriceChange { get; set;}
    public int Quantity { get; set;}
    public int InvestedValue { get; set;}
}

public class MutualFund
{
    public long MfId { get; set; }
    public string Name { get; set; }
    public decimal LastNAV { get; set; }
    public decimal LastNAVChange { get; set; }
    public int Quantity { get; set; }
    public int InvestedValue { get; set; }
}

1.执行聚合管道。

MongoClientSettings settings = MongoClientSettings.FromConnectionString(
    "Your Connection string"
);

MongoClient _client = new MongoClient(settings);

IMongoDatabase _db = _client.GetDatabase("Your Database name");
IMongoCollection<BsonDocument> _collection = _db.GetCollection<BsonDocument>("Portfolio");

BsonDocument[] pipeline = new BsonDocument[]
{
    new BsonDocument("$lookup",
    new BsonDocument
        {
            { "from", "Securities" },
            { "localField", "Stocks.StockId" },
            { "foreignField", "StockId" },
            { "as", "Securities" }
        }),
    new BsonDocument("$lookup",
    new BsonDocument
        {
            { "from", "MutualFunds" },
            { "localField", "MutualFunds.MutualFundId" },
            { "foreignField", "MfId" },
            { "as", "Mfs" }
        }),
    new BsonDocument("$set",
    new BsonDocument
        {
            { "Securities",
    new BsonDocument("$map",
    new BsonDocument
                {
                    { "input", "$Securities" },
                    { "as", "s" },
                    { "in",
    new BsonDocument("$mergeObjects",
    new BsonArray
                        {
                            "$$s",
                            new BsonDocument("$first",
                            new BsonDocument("$filter",
                            new BsonDocument
                                    {
                                        { "input", "$Stocks" },
                                        { "cond",
                            new BsonDocument("$eq",
                            new BsonArray
                                            {
                                                "$$s.StockId",
                                                "$$this.StockId"
                                            }) }
                                    }))
                        }) }
                }) },
            { "Mfs",
    new BsonDocument("$map",
    new BsonDocument
                {
                    { "input", "$Mfs" },
                    { "as", "m" },
                    { "in",
    new BsonDocument("$mergeObjects",
    new BsonArray
                        {
                            "$$m",
                            new BsonDocument("$first",
                            new BsonDocument("$filter",
                            new BsonDocument
                                    {
                                        { "input", "$MutualFunds" },
                                        { "cond",
                            new BsonDocument("$eq",
                            new BsonArray
                                            {
                                                "$$m.MutualFundId",
                                                "$$this.MfId"
                                            }) }
                                    }))
                        }) }
                }) }
        }),
    new BsonDocument("$unset",
    new BsonArray
        {
            "Stocks",
            "MutualFunds",
            "Securities._id",
            "Mfs._id",
            "Mfs.MutualFundId"
        })
};

List<PortfolioOutputModel> result = (await _collection.AggregateAsync<PortfolioOutputModel>(pipeline))
                .ToList();