Skip to main content

Working with MongoDB in .Net Core (Part 3) - Definitions and Builders

                
Mongo Queries - C# Driver


Writing Complex Mongo Queries using Aggregation - Builders and BsonDocuments

Builders - 

1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
//Filter Definition Builder
var builder = Builders<T>.Filter;
var filter = builder.Ne(_=>_.{field}, true);
filter = filter & builder.Eq(_=>_.{field}, value);
filter = filter & builder.Gte(_=>_.{field}, value);
filter = filter & builder.Lte(_=>_.{field}, value);
filter = filter & builder.In(_=>_.{field}, value);
filter = filter & builder.In(_=>_.{field}, new List<string> { value1, value2});
filter = filter & builder.AnyEq(_=>_.{field}, value);
filter = filter & builder.Or(_=>_.{field}, value);
filter = filter & builder.And(_=>_.{field}, value);
filter = filter & builder.ElemMatch(_=>_.{field}, t => t.Id == Id, t.Key == Key);


1
2
3
4
5
6
7
8
9
//Sort Definition Builder
var sortfilter = Builders<T>.Sort.Descending(_=>_.{field});

//Update Definition Builder
UpdateDefinition<T> updateDef = Builders<T>.Update.Set(_=>_.{Field1}, value);
update = ({Field2} != null) ? updateDef.Set(_=>_.{Field3}, value) : updateDef;

//Projection Definition Builder
var projection = Builders<BsonDocument>.Projection.Include("x").Include("y").Exclude("_id");

BsonDocument -

Building mongo Queries that have complex conditions and search criteria can be appended by checking If/else conditions
1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
//Match
var match = new BsonDocument(true);   //true is to allow duplicate keys to be added to the Bson Document
match.Add("{field}", new BsonDocument{ { "$ne" , value }} );
match.Add("{field}", new BsonDocument{ { "$eq" , value }} );
match.Add("{field}", new BsonDocument{ { "$lt" , value }} );
match.Add("{field}", new BsonDocument{ { "$gt" , value }} );
match.Add("{field}", new BsonDocument{ { "$in" , new BsonArray(values) }} );
match.Add("{field}", new BsonDocument{ { "$nin" , new BsonArray(values) }} );
match.Add("{field}", new BsonDocument{ { "$gte" , dateRangeStart }, { "$lte" , dateRangeEnd }} );
match.Add("{field}", new BsonDocument{ { "$gte" , date }} );
match.Add("{field}", new BsonArray() { new BsonDocument {{ "{field", value} , {"{field2", value }}} );
match.Add("{field}", new BsonDocument{ { "$elemMatch" , newBsonDocument {{ "{field}", value}, {"{field2", value }} }} );


1
2
3
4
//Sort
var sort = new BsonDocument();
sort.Add(new BsonDocument("{field}", 1));  //Ascending
sort.Add(new BsonDocument("{field}", -1)); //Descending

Building Mongo Queries that don't have complex conditions

 
//Building Mongo Queries that are not too complex
private BsonDocument[] BuildPipeline()
{
    var match = new BsonDocument
    {
        {
            "$match", new BsonDocument { {"field", value}, 
                                         {"field", value}, 
                                         {"field", new BsonDocument() { { "$in", new BsonArray(values)}}},
                                         { "field" , new BsonDocument { { "$elemMatch" , new BsonDocument { { "field", value }}}}}};
        }
    };

    var lookup = new BsonDocument
    {
        {
            "$lookup", new BsonDocument { { "from", "field"}, {"localField", "field"}, {"foreignField", "field"}, { "as", "field"}}
        }
    };

    var sort = new BsonDocument{
        {
            "$sort" , new BsonDocument{ { "field", -1 } }
        }
    };

    var limit = new BsonDocument{
        {
            "$limit" , limit }
        }
    };

    var group = new BsonDocument
    {
        {
            "$group", new BsonDocument 
            { 
                { "_id", "groupbyfield"},
                {"id", new BsonDocument() { { "$first", "field"}}},
                {"title", new BsonDocument() { { "$first", "field"}}},
                {"desc", new BsonDocument() { { "$first", "field"}}},
                {"objects", new BsonDocument() { { "$push", "$$ROOT"}}},
            }
        }
    };

    var project = new BsonDocument{
        {
            "$project" , new BsonDocument{ { "field", 0 } }
        }
    };

    var unwind = = new BsonDocument{
        {
            "$unwind" , "field" }
        }
    };

    BsonDocument[] pipe = new[] { match, lookup, sort, limit, group, project, unwind };
    
    return pipeline;
}

Building Pipeline for Aggregation Call -

1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
//Pipeline Builder using Builders
var pipe = new EmptyPipelineDefinition&lt;T&gt;()
           .Match(filter)
           .Project(project)
           .Sort(sort)
           .Limit(limit)
var aggregate = await Aggregate(pipe).ConfigureAwait(false);
var result = { aggregate.ToList(), aggregate.Count() };

//Pipeline Query to get total Count of documents
var pipe = new EmptyPipelineDefinition<T>()
           .Match(match)
           .Project(new BsonDocument("id", 1))    //The idea is to project only one field so that Count() performance is increased
           .Count();

var aggregate = await Aggregate(pipe).ConfigureAwait(false);
return (aggregate.count() == 0) ? 0 : aggregate.First().Count;

Labels:

Comments

Post a Comment

Popular posts from this blog

How to clear Visual Studio Cache

How to clear visual studio cache Many times, during development you would face situations where project references are not loaded properly or you get missing/error DLL's. This is because the Component cache gets corrupted randomly and without any warnings. The first option that needs to be done is to clear component cache and restart Visual Studio since the Cache might be holding onto previous DLL versions. Here are the steps on how to clear Visual Studio Cache, Clearing Component Cache: Close all Visual Studio Instances running in your machine. Also, make sure devenv.exe is not running in the Task Manager Delete the Component cache directory - %USERPROFILE%\AppData\Local\Microsoft\VisualStudio\1x.0\ComponentModelCache Restart Visual Studio The above steps should fix the cache issue most of the times, but some times that is not enough and you need to perform the below steps as well. Clearing User's Temp Folder: Open the temp folder in this locatio n -  %USERPROFILE%\AppData\Loc
231 comments
Read more

How to dependency inject to static class

.Net core supports dependency injection. There are many ways that you can inject services like constructor injection, action method injection, property injection. But there will be scenarios where you need to inject dependency services to static classes. For example, injecting services to extension methods. First, create a static class with a one property IServiceProvider type public void ConfigureServices(IServiceCollection services) { services.AddScoped<ILoggerEntry, LoggerEntry>(); services.AddTransient<IMongoRepository, MongoRepository>(); } Second, configure your services in ConfigureServices() method in Startup.cs and define the lifetime of the service instance using either Transient, Scoped or Singleton types. public void ConfigureServices(IServiceCollection services) { services.AddScoped<ILoggerEntry, LoggerEntry>(); services.AddTransient<IMongoRepository, MongoRepository>(); } For the next step to configure the Static class provider proper
Post a Comment
Read more

PCF Health Check Delay - Invocation timeout

In PCF we can set up the health check invocation timeout to execute X seconds after the instance has been created.  But before that, let's understand the PCF Health Check Lifecycle. Stage 1: The application is deployed to PCF Stage 2: When deploying the app, a health check type is specified and optionally a timeout. If a health check type is not specified, then the monitoring process defaults to a port health check Stage 3: Cloud Controller stages, starts, and runs the application Stage 4: Based on the type specified for the app, Cloud Controller configures a health check    that runs periodically for each app instance Stage 5: When Diego starts an app instance, the app health check runs every two seconds until a response indicates that the app instance is healthy or until the health check timeout elapses. The 2-seconds health check interval is not configurable Stage 6: When an app instance becomes healthy, its route is advertised, if applicable.                  Subsequent hea
1 comment
Read more