In our previous post, we discussed about writing a data access layer for mongodb. So, let's discuss a bit about each method.
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;
}
This methods are used to insert records to a specific collection. The T is a
generic type which you can pass any entity. For example, lets say you have a Person class. and you are going to add a new person. So what you need is to pass the Person object to this method. Normally collections are named as the class name so that it's not going to be clear.
public bool Insert(Person p)
{
return dal.Insert(p);
}
The sample Person class will looks like below. You must have the
[BsonId]
public ObjectId _id { get; set; }
so that the MongoDB can keep the unique code generated upon saving a new person.
public class Person
{
private int _idPerson;
private string _mobileNumber;
private string _lastName;
private string _firstName;
private string _username;
private string _password;
private DateTime _lastModified;
[BsonId]
public ObjectId _id { get; set; }
public int IdPerson
{
get { return _idPerson; }
set { _idPerson = value; }
}
public string FirstName
{
get { return _firstName; }
set { _firstName = value; }
}
public string LastName
{
get { return _lastName; }
set { _lastName = value; }
}
public string MobileNumber
{
get { return _mobileNumber; }
set { _mobileNumber = value; }
}
public string Username
{
get { return _username; }
set { _username = value; }
}
public string Password
{
get { return _password; }
set { _password = value; }
}
public DateTime LastModified
{
get { return _lastModified; }
set { _lastModified = value; }
}
}
Lets see how we can use replace function to update/replace a specific record.
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;
}
This 2 methods will help with our update / replace of persons as below.
public bool Replace(Person p)
{
return dal.Replace(p, "IdPerson", p.IdPerson);
}
Here we have the p as Person object that has all the existing and modified data. Also we use IdPerson as the key to update the person.
So, the deletion is done as below.
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);
}
So, you can either use _id which is MongoDB ID value of the record to delete or you can pass a matching attribute with it's value to delete.
Finally, the selection can be done like this;
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();
}
Methods can be used as ;
public List<Person> Select()
{
return dal.Select<Person>();
}
The matching type Person will return a list of persons from the collection.
So, try using these methods and if any let me know.
Happy coding...
