C# Mongodb Data Access Layer

As we have discussed in our previous post, lets focus on a working data access layer that we can use for our mongodb database.

As a collection based database, it's a bit different as how we should deal with records (collections) here. Let's have a look at the code.

 public class MongoDBCRUD  
   {  
     MongoClient client;  
     private IMongoDatabase mongoDatabase;  
     string DBMaster, DBName;  
     public MongoDBCRUD()  
     {  
     }  
     public MongoDBCRUD(string MasterDatabase)  
     {  
       DBMaster = MasterDatabase;  
     }  
     private void Connect()  
     {        
       DBName = DBMaster ?? (Common.DBName != null ? Common.DBName.ToString() : string.Empty);  
       if (!string.IsNullOrEmpty(Common.ConString))  
         client = new MongoClient(Common.ConString);  
       if (!string.IsNullOrEmpty(DBName))  
         mongoDatabase = client.GetDatabase(DBName);  
     }  
     public bool Insert<T>(T RecordToInsert)  
     {  
       return Insert<T>(typeof(T).Name, RecordToInsert);  
     }  
     public bool Insert<T>(string TableName, T RecordToInsert)  
     {  
       Connect();  
       var collection = mongoDatabase.GetCollection<T>(TableName);  
       collection.InsertOne(RecordToInsert);  
       return true;  
     }  
     public bool Replace<T>(T RecordToUpsert, string UpdateColumnName, BsonValue WhereValue)  
     {  
       return Replace<T>(typeof(T).Name, RecordToUpsert, UpdateColumnName, WhereValue);  
     }  
     public bool Replace<T>(string TableName, T RecordToUpsert, string UpdateColumnName, BsonValue WhereValue)  
     {  
       Connect();  
       var filter = Builders<T>.Filter.Eq(UpdateColumnName, WhereValue);        
       var collection = mongoDatabase.GetCollection<T>(TableName);        
       var result = collection.ReplaceOne(filter, RecordToUpsert);  
       return result.IsAcknowledged;  
     }  
     public void Delete<T>(BsonValue WhereValue)  
     {  
       Delete<T>(typeof(T).Name, "_id", WhereValue);  
     }  
     public void Delete<T>(string DeleteColumnName, BsonValue WhereValue)  
     {  
       Delete<T>(typeof(T).Name, DeleteColumnName, WhereValue);  
     }      
     public void Delete<T>(string TableName, string DeleteColumnName, BsonValue WhereValue)  
     {  
       Connect();  
       var collection = mongoDatabase.GetCollection<T>(TableName);  
       var filter = Builders<T>.Filter.Eq(DeleteColumnName, WhereValue);  
       collection.DeleteOne(filter);  
     }  
     public List<T> Select<T>()  
     {  
       return Select<T>(typeof(T).Name);  
     }  
     public List<T> Select<T>(string TableName)  
     {  
       Connect();  
       var collection = mongoDatabase.GetCollection<T>(TableName);  
       return collection.Find(new BsonDocument()).ToList();  
     }  
     public List<T> Select<T>(BsonValue WhereValue, string SelectColumnName = null)  
     {  
       Connect();  
       if (string.IsNullOrEmpty(SelectColumnName))  
         SelectColumnName = "_id";  
       return Select<T>(typeof(T).Name, SelectColumnName, WhereValue);  
     }  
     public List<T> Select<T>(string TableName, string SelectColumnName, BsonValue WhereValue)  
     {  
       Connect();  
       var collection = mongoDatabase.GetCollection<T>(TableName);  
       var filter = Builders<T>.Filter.Eq(SelectColumnName, WhereValue);  
       return collection.Find(filter).ToList();  
     }      
     public T Select<T>(Dictionary<string, BsonValue> WhereValue)  
     {  
       return Select<T>(typeof(T).Name, WhereValue);  
     }  
     public T Select<T>(string TableName, Dictionary<string, BsonValue> WhereValue)  
     {  
       Connect();  
       var collection = mongoDatabase.GetCollection<T>(TableName);  
       FilterDefinition<T>[] filterDefinition = new FilterDefinition<T>[WhereValue.Count];  
       FilterDefinition<T> filter;  
       int i = 0;  
       foreach (var v in WhereValue)  
       {  
         filter = Builders<T>.Filter.Eq(v.Key, v.Value);  
         filterDefinition[i] = filter;  
         i++;  
       }  
       return collection.Find(Builders<T>.Filter.And(filterDefinition)).FirstOrDefault();  
     }  
     public int GetNextNumber<T>()  
     {  
       Connect();  
       var TableName = typeof(T).Name;  
       var value = this.Select<AutoIncrement>().Where(x => x.Table.Equals(TableName)).ToList().FirstOrDefault();  
       if (value == null)  
         return 1;  
       else  
         return value.TableId + 1;  
     }  
     public void SetNextNumber<T>(T Table, int id)  
     {  
       Connect();  
       var TableName = typeof(T).Name;  
       AutoIncrement autoIncrement = new AutoIncrement() { TableId = id, Table = TableName };  
       if (id > 1)  
       {   
         var filter = Builders<AutoIncrement>.Filter.Eq("Table", TableName);  
         var update = Builders<AutoIncrement>.Update.Set("TableId", id);  
         var collection = mongoDatabase.GetCollection<AutoIncrement>("AutoIncrement");  
         var result = collection.UpdateOne(filter, update);  
       }  
       else  
         this.Insert<AutoIncrement>(autoIncrement);        
     }  
   }  

You can copy this class and use it directly in your application. Anyway, it's got few more functions as you can have a parent and child database connections with primary keys as a value added function.

In our next post, we will talk a bit more about individual functions.
till that play with this code.

happy coding.