Vfrdtyky

I have the below class structure. I'm trying to call UpdateAsync by passing only a part of the object. For some reason it is respecting the BsonIgnoreIfDefault only at the root object level TestObject class, but not on TestProduct.

public class TestObject

{

    [BsonId]

    [BsonRepresentation(BsonType.ObjectId)]

    [BsonIgnoreIfDefault]

    public string Id { get; set; }

    [Required]

    public string KoId { get; set; }

    [BsonIgnoreIfDefault]

    public string Summary { get; set; }

    public TestProduct Product { get; set; }

}



public class TestProduct

{

    [BsonIgnoreIfDefault]

    public string Name { get; set; }

    [BsonIgnoreIfDefault]

    public List<string> Skus { get; set; }

}

Here's a snippet of my integration test:

public async Task EndToEndHappyPath()

{

    const string summary = "This is a summary";

    var obj = new TestObject

    {

        Summary = summary,

        KoaId = "1234",

        Product = new TestProduct

        {

            Name = "laptop",

            Skus = new List<string>

            {

                "Memory"

            }

        }

    };



    // CREATE

    await _mongoAsyncRepository.CreateAsync(obj);



    obj = new TestObject

    {

        KoaId = koaId,

        Description = description,

        Product = new TestProduct

        {

            Skus = new List<string>

            {

                "RAM"

            }

        }

    };



    // UPDATE

    var response = await _mongoAsyncRepository.UpdateAsync(koaId, obj);

    response.ShouldBeTrue();



    // RETRIEVE

    result = await _mongoAsyncRepository.RetrieveOneAsync(koaId);

    testObject = (result as TestObject);

    testObject.Product.ShouldNotBeNull();

    // this is failing; Name value is null in MongoDb

    testObject.Product.Name.ShouldBe("laptop");

    testObject.Product.Skus.ShouldNotBeNull();

    testObject.Product.Skus.Count.ShouldBe(1);

    testObject.Product.Skus[0].ShouldBe("RAM");

}



public async Task<bool> UpdateAsync(string id, T obj)

{

    try

    {

        _logger.Log(new KoaLogEntry(KoaLogLevel.Debug, $"Attempting to update a {typeof(T)} {id} document."));



        //var actionResult = await GetMongoCollection()?.ReplaceOneAsync(new BsonDocument("KoaId", id), obj);



        var updated = new BsonDocument

{

    {

        "$set", bsonDoc

    }

};

UpdateDefinition<BsonDocument> updatedObj = UpdateBuilder.DefinitionFor(updated);





        var actionResult = await GetMongoCollection()?.UpdateOneAsync(new BsonDocument("KoaId", id), updated);



        _logger.Log(new KoaLogEntry(KoaLogLevel.Debug, $"Updated a {typeof(T)} {id} document. IsAcknowledged = {actionResult.IsAcknowledged}; ModifiedCount = {actionResult.ModifiedCount}"));



        return actionResult.IsAcknowledged

               && actionResult.ModifiedCount > 0;

    }

    catch (Exception exc)

    {

        _logger.Log(new KoaLogEntry(KoaLogLevel.Error, exc.Message, exc));

        throw;

    }

}



private readonly IMongoClient _client;



protected IMongoCollection<T> GetMongoCollection()

{

    var database = _client.GetDatabase(this.DatabaseName);

    return database.GetCollection<T>(typeof(T).Name);

}

For some reason Name is getting overwritten to null though I have put the BsonIgnoreIfDefault attribute on it.

Please let me know what I'm missing.
Thanks
Arun

I did some research and it seems that this is not supported out of the box.

BsonIgnoreIfDefault means "do not include in document in db if default" it does NOT mean "ignore in updates".

Your update command

var actionResult = await GetMongoCollection()?.UpdateOneAsync(new BsonDocument("KoaId", id), updated);

should have the same behavior as this:

await GetMongoCollection().ReplaceOneAsync(_ => _.KoaId == id, obj);

It will replace the the existing document.

The docs say (and I assume, that the c# driver does no magic):

If the document contains only field:value expressions, then:
The update() method replaces the matching document with the document. The update() method does not replace the _id value. For an example, see Replace All Fields.

https://docs.mongodb.com/manual/reference/method/db.collection.update/

So you're doing a replace and all properties having default values will not be written to new new document:

// document after replace without annotations (pseudocode, fragment only)

{ 

  KoaId: "abc",

  Summary: null

}



// with Summary annotated with BsonIgnoreIfDefault

{ 

  KoaId: "abc"

}

The only solution I found, is to write a builder that creates UpdateDefinitions from an object and add custom attributes. This is my first version that may help as a start:

/// <summary>

///     Ignore property in updates build with UpdateBuilder.

/// </summary>

[AttributeUsage(AttributeTargets.Property)]

public class BsonUpdateIgnoreAttribute : Attribute

{

}



/// <summary>

///     Ignore this property in UpdateBuild if it's value is null

/// </summary>

[AttributeUsage(AttributeTargets.Property)]

public class BsonUpdateIgnoreIfNullAttribute : Attribute

{

}



public static class UpdateBuilder

{

    public static UpdateDefinition<TDocument> DefinitionFor<TDocument>(TDocument document)

    {

        if (document == null) throw new ArgumentNullException(nameof(document));



        var updates = _getUpdateDefinitions<TDocument>("", document);

        return Builders<TDocument>.Update.Combine(updates);

    }



    private static IList<UpdateDefinition<TDocument>> _getUpdateDefinitions<TDocument>(string prefix, object root)

    {

        var properties = root.GetType().GetProperties();

        return properties

            .Where(p => p.GetCustomAttribute<BsonUpdateIgnoreAttribute>() == null)

            .Where(p => p.GetCustomAttribute<BsonUpdateIgnoreIfNullAttribute>() == null || p.GetValue(root) != null)

            .Select(p => _getUpdateDefinition<TDocument>(p, prefix, root)).ToList();

    }



    private static UpdateDefinition<TDocument> _getUpdateDefinition<TDocument>(PropertyInfo propertyInfo,

        string prefix,

        object obj)

    {

        if (propertyInfo.PropertyType.IsClass &&

            !propertyInfo.PropertyType.Namespace.AsSpan().StartsWith("System") &&

            propertyInfo.GetValue(obj) != null)

        {

            prefix = prefix + propertyInfo.Name + ".";

            return Builders<TDocument>.Update.Combine(

                _getUpdateDefinitions<TDocument>(prefix, propertyInfo.GetValue(obj)));

        }



        return Builders<TDocument>.Update.Set(prefix + propertyInfo.Name, propertyInfo.GetValue(obj));

    }

}

Please not that this is not optimized for performance.

You can use it like so:

        var updateDef = UpdateBuilder.DefinitionFor(updatedDocument);

        await Collection.UpdateOneAsync(_ => _.Id == id, updateDef);