How to disable discriminator field in MongoDb (C# driver)

Question

Is there a way to disable completely (for all classes) the discriminator ("_t") fields from being added to the bson documents? I am referring to: mongo-csharp-driver/polymorphism

Answer 1

Let's say we have a Square and Rectangle that inherit from Shape.

public abstract class Shape
{
    public ObjectId Id { get; set; }
}

public sealed class Square : Shape
{
    public int Size { get; set; }
}

public sealed class Rectangle : Shape
{
    public int Width { get; set; }
    public int Height { get; set; }
}

Like you said if we run the following code.

var client = new MongoClient();

var db = client.GetDatabase("test");

var shapes = db.GetCollection<Shape>("shapes");

await shapes.InsertManyAsync(new Shape[]
{
    new Square{Size = 10},
    new Rectangle{Height = 5, Width = 4}
});

We'll get the following inserted into MongoDB

db.shapes.find()
{ "_id" : ObjectId("5f4e2affc23dde5a501bdf0b"), "_t" : "Square", "Size" : 10 }
{ "_id" : ObjectId("5f4e2affc23dde5a501bdf0c"), "_t" : "Rectangle", "Width" : 4, "Height" : 5 }

Initially, I thought we'd be able to set the DiscriminatorIsRequired flag on the BsonClassMap and wrap that in a convention, however, from trying this it seems to fail due to the following bit of logic in the MongoDB C# Driver.

private bool ShouldSerializeDiscriminator(Type nominalType)
{
    return (nominalType != _classMap.ClassType || _classMap.DiscriminatorIsRequired || _classMap.HasRootClass) && !_classMap.IsAnonymous;
}

https://github.com/mongodb/mongo-csharp-driver/blob/9e567e23615c8bb5c7ac1489427c2d15b2124522/src/MongoDB.Bson/Serialization/Serializers/BsonClassMapSerializer.cs#L722

So because there's no way for us to tell the serializer we don't want to include a discriminator we'll have to give it a convention instead that does nothing. If we create an IDiscriminatorConvention that pretty much does nothing and returns back null for the discriminator then the driver won't add this to the document.

public class NullDiscriminatorConvention : IDiscriminatorConvention
{
    public static NullDiscriminatorConvention Instance { get; }
        = new NullDiscriminatorConvention();

    public Type GetActualType(IBsonReader bsonReader, Type nominalType)
        => nominalType;

    public BsonValue GetDiscriminator(Type nominalType, Type actualType)
        => null;

    public string ElementName { get; } = null;
}

This discriminator convention then needs to be registered against each type.

BsonSerializer.RegisterDiscriminatorConvention(typeof(Square), NullDiscriminatorConvention.Instance);
BsonSerializer.RegisterDiscriminatorConvention(typeof(Rectangle), NullDiscriminatorConvention.Instance);

Alternately if we want it on all types you could do a little bit of reflection.

var shapeTypes = AppDomain.CurrentDomain.GetAssemblies()
    .SelectMany(domainAssembly => domainAssembly.GetTypes(),
        (domainAssembly, assemblyType) => new {domainAssembly, assemblyType})
    .Where(t => @t.assemblyType.IsSubclassOf(typeof(Shape)))
    .Select(t => @t.assemblyType).ToArray();

foreach (var shapeType in shapeTypes)
{
    BsonSerializer.RegisterDiscriminatorConvention(shapeType, NullDiscriminatorConvention.Instance);
}

Now if we re-run our code.

var shapeTypes = AppDomain.CurrentDomain.GetAssemblies()
    .SelectMany(domainAssembly => domainAssembly.GetTypes(),
        (domainAssembly, assemblyType) => new {domainAssembly, assemblyType})
    .Where(t => @t.assemblyType.IsSubclassOf(typeof(Shape)))
    .Select(t => @t.assemblyType).ToArray();

foreach (var shapeType in shapeTypes)
{
    BsonSerializer.RegisterDiscriminatorConvention(shapeType, NullDiscriminatorConvention.Instance);
}

var client = new MongoClient();

var db = client.GetDatabase("test");

var shapes = db.GetCollection<Shape>("shapes");

await shapes.InsertManyAsync(new Shape[]
{
    new Square{Size = 10},
    new Rectangle{Height = 5, Width = 4}
});

we'll get our expected output.

db.shapes.find()
{ "_id" : ObjectId("5f4e2d63ed12d7c5d3638d36"), "Size" : 10 }
{ "_id" : ObjectId("5f4e2d63ed12d7c5d3638d37"), "Width" : 4, "Height" : 5 }

Answer 2

One option is using Newtonsoft bson serializer (Newtonsoft.Json.Bson) which gives a lot of serialization options.
It isn't efficient since you need to write the bson to a stream and then read it from there with MongoDb reader but it provides lots of customization option. Example code:

class BsonDocBuilder
    {
        private readonly MemoryStream _memStream = new MemoryStream();
        private readonly JsonSerializerSettings _serializeSettings = new JsonSerializerSettings();
        private readonly JsonSerializer _jsonSerializer; 
        public BsonDocBuilder()
        {
            _jsonSerializer = JsonSerializer.Create(_serializeSettings);
        }

        public BsonDocument ToBson<T>(T value)
        {
            BsonDocument bd;
            try
            {
                using (BsonDataWriter dataWriter = new BsonDataWriter(_memStream))
                {
                    dataWriter.CloseOutput = false;
                    _jsonSerializer.Serialize(dataWriter, value);
                }
                bd= BsonSerializer.Deserialize<BsonDocument>(_memStream.ToArray());
            }
            finally
            {
                _memStream.SetLength(0);                    
            }

            return bd;
        }
    }