How can I join ClassB documents in a MongoDB aggregation without storing empty arrays in .NET?

When you remove [BsonIgnore] the $lookup result is assigned to the ClassesB field—even if it is empty—and that empty array is stored. Adding [BsonIgnore] tells the serializer to skip that property on write, but then the lookup framework can’t map into it (thus the “Expression not supported: t.ClassesB” error).

There are two main workarounds:

1. Use a custom serializer or a “ShouldSerialize” pattern.

   Instead of marking ClassesB with [BsonIgnore], you can customize its serialization so that when it’s empty it returns null. One approach is to create a custom serializer that writes out the field only if the list is not empty. Alternatively, you might create a read-only property that does the conditional check while keeping the underlying field for aggregation:

   CSHARPCopied
   public class ClassA
   {
       [BsonId]
       [BsonRepresentation(BsonType.String)]
       public required Guid Id { get; init; }
   
       public required List<Guid> ClassBIds { get; init; }
   
       // Backing field for the lookup result
       private List<ClassB>? _classesB;
   
       // This property is used for mapping but will only be serialized if not empty.
       [BsonElement("ClassesB")]
       [BsonIgnoreIfNull]
       public List<ClassB>? ClassesB
       {
           get => _classesB == null || !_classesB.Any() ? null : _classesB;
           init => _classesB = value;
       }
   }

   With this approach, when the aggregation lookup returns an empty array, the getter returns null and, thanks to [BsonIgnoreIfNull], nothing gets written to the database. (You’ll need to ensure that your driver settings or conventions honor null values as “missing”.)

2. Use a separate aggregation/read model.

   Often it is useful to separate the read (aggregation) model from the write model. In this scenario you keep ClassA “clean” (without the populated but unwanted field) for writes and create a separate DTO used only for querying. This DTO would include the ClassesB property (without [BsonIgnore]) so that the lookup pipeline works as expected. For example:

   CSHARPCopied
   public class ClassAReadModel
   {
       [BsonId]
       [BsonRepresentation(BsonType.String)]
       public required Guid Id { get; init; }
       
       public required List<Guid> ClassBIds { get; init; }
       
       // This property is used only during read/aggregation.
       public List<ClassB> ClassesB { get; init; } = new();
   }

   Then use this read model as the output type for your aggregation pipeline:

   CSHARPCopied
   var lookup = new BsonDocument
   {
       { "$lookup", new BsonDocument
           {
               { "from", "bCollection" },
               { "localField", nameof(ClassA.ClassBIds) },
               { "foreignField", nameof(ClassB.Id) },
               { "as", nameof(ClassAReadModel.ClassesB) }
           }
       }
   };
   
   var pipeline = PipelineDefinition<ClassA, ClassAReadModel>.Create(lookup);
   var documents = _ACollection.Aggregate(pipeline);

   In this approach your “write” model (ClassA) remains unaffected by the aggregate results, and you don’t accidentally store an unwanted empty array.

Both approaches solve the problem. The first lets you keep a single model by conditionally serializing ClassesB only when it’s non-empty. The second separates read and write concerns altogether.

Choose the approach that best fits your application’s design and workflow.