MongoDB is a NoSQL document-oriented database that allows you to define JSON based documents which are schema independent. The schema can be mapped with Tables in a Relational Database. A schema in MongoDB is called as collection, and a record in this schema is called as document
Download an ASP.NET MVC CMS - Free Trial
In open source modern web applications, the use of a NoSQL database is gaining popularity due to its non-relational behavior. In this demo, we will create a Web API using ASP.NET Core which will perform CRUD Operations on a collection. The following diagram explains the implementation of the application.
The advantage of a Web API is that it can be used as HTTP services and can be subscribed by any client application ranging from Desktop to Mobiles. Using Web API as a medium, these client apps can easily interact with a NoSQL database like MongoDB.
Web API and MongoDB - The Implementation
We need MongoDB for creating collections and storing documents in it. MongoDB can be downloaded from this link. Install the database. Once the installation is over, the system drive will create a MongoDB folder in the following path
C:\Program Files\MongoDB
|
We also need to create a data folder where the data will be stored. On my machine I have created E:\MongoDbData\data
Open the Command prompt and navigate to the following folder
C:\Program Files\MongoDB\Server\3.2\bin
|
and run the command as shown in the following image
This will connect to MongoDB on port 27017.
Open another instance of the command prompt and navigate to the bin folder and run the following command
This will connect to the default test database. Run the following command on > (command prompt)
> use EmployeeDB
|
This will create a database of name EmployeeDB if it does not exist already, else it will be opened for transactions if the database already exists. In this database we can create transaction using the following command
db.createCollection(
'Products'
)
|
The Schema for the Products collection can be defined using following command from the command prompt
db.Products.insert({
'ProductId'
:1,
'ProductName'
:
'Desktop All in One'
,
'Price'
:43000,
'Category'
:
'Electronics'
})
|
Run the following command
>db.Products.find({})
|
The following result will be displayed
The schema will add _id property. This property will be an ObjectId which will be generated automatically.
Now since the database and collection is ready, we can create a Web API application. Please visit this link to read about creating Web API using MVC 6.
Creating the MongoDB Application
We will be using Visual Studio 2015 for creating this application. We need to install ASP.NET Core which can be downloaded from this link.
Step 1: Open Visual studio and create a new ASP.NET Web Application as shown in the following image
Name this application as MVC6_WEBAPI_MongoDB. Click on the OK button which will open the following window which shows ASP.NET Templates. Select Web API as shown in the following image
This will create a Web API project.
Step 2: Open the project.json file and in the dependencies section, add the following package dependency:
"mongocsharpdriver": "2.3.0"
|
Save the project and the Mongo CSharp driver will be installed for the project.
Step 3: In the project add the Models folder, in this add a new class file of name Product.cs. Add the following code in this file
using
MongoDB.Bson;
using
MongoDB.Bson.Serialization.Attributes;
namespace
MVC6_WEBAPI_MongoDB.Models
{
public
class
Product
{
public
ObjectId Id {
get
;
set
; }
[BsonElement(
"ProductId"
)]
public
int
ProductId {
get
;
set
; }
[BsonElement(
"ProductName"
)]
public
string
ProductName {
get
;
set
; }
[BsonElement(
"Price"
)]
public
int
Price {
get
;
set
; }
[BsonElement(
"Category"
)]
public
string
Category {
get
;
set
; }
}
}
|
The class contains Id property of the type ObjectId. This property is mandatory so that the CLR object can be mapped with Collection in MongoDB. The class contains properties having the BsonElement attribute applied on it. This represent the mapped property with the MongoDB collection.
Step 3: Add the DataAccess.cs class file in the Models folder with the following code in it
using
MongoDB.Bson;
using
MongoDB.Driver;
using
MongoDB.Driver.Builders;
using
System.Collections.Generic;
namespace
MVC6_WEBAPI_MongoDB.Models
{
public
class
DataAccess
{
MongoClient _client;
MongoServer _server;
MongoDatabase _db;
public
DataAccess()
{
_client =
new
MongoClient(
"mongodb://localhost:27017"
);
_server = _client.GetServer();
_db = _server.GetDatabase(
"EmployeeDB"
);
}
public
IEnumerable<Product> GetProducts()
{
return
_db.GetCollection<Product>(
"Products"
).FindAll();
}
public
Product GetProduct(ObjectId id)
{
var res = Query<Product>.EQ(p=>p.Id,id);
return
_db.GetCollection<Product>(
"Products"
).FindOne(res);
}
public
Product Create(Product p)
{
_db.GetCollection<Product>(
"Products"
).Save(p);
return
p;
}
public
void
Update(ObjectId id,Product p)
{
p.Id = id;
var res = Query<Product>.EQ(pd => pd.Id,id);
var operation = Update<Product>.Replace(p);
_db.GetCollection<Product>(
"Products"
).Update(res,operation);
}
public
void
Remove(ObjectId id)
{
var res = Query<Product>.EQ(e => e.Id, id);
var operation = _db.GetCollection<Product>(
"Products"
).Remove(res);
}
}
}
|
The above code uses the following classes:
MongoServer - This represents an instance of the MongoDB Server.
MongoClient - This class is used to read the server instance for performing operations on the database. The constructor of this class is passed with the MongoDB Connection string as shown in the following box
"mongodb://localhost:27017"
|
MongoDatabase - This represents Mongo Database for performing operations. This class provides following methods
- GetCollection<T>(collection)
- · T is the CLR object to be collection.
- · This returns MongoCollection.
- Methods
- FindAll() - Returns all documents in collection()
- FindOne() - Returns a single document based on Mongo Query object generated based on _id.
- Save() - Save a new document in collection.
- Update() - Update a document.
- Remove() - Remove a document.
The above code uses all these methods for performing CRUD operations.
Step 4: We will register the DataAccess class in the Dependency Injection feature provided by the ASP.NET Core. To do this open the Start.cs file and add the following line in ConfigureServices() method
public
void
ConfigureServices(IServiceCollection services)
{
services.AddTransient<DataAccess>();
services.AddMvc();
}
|
Step 5: In the Controllers folder, add a new Web API Controller class of name ProductAPIController as shown in the following image
In this class add the following code
using
System.Collections.Generic;
using
Microsoft.AspNet.Mvc;
using
MVC6_WEBAPI_MongoDB.Models;
using
MongoDB.Bson;
namespace
MVC6_WEBAPI_MongoDB.Controllers
{
[Route(
"api/Product"
)]
public
class
ProductAPIController : Controller
{
DataAccess objds;
public
ProductAPIController()
{
objds = d;
}
[HttpGet]
public
IEnumerable<Product> Get()
{
return
objds.GetProducts();
}
[HttpGet(
"{id:length(24)}"
)]
public
IActionResult Get(
string
id)
{
var product = objds.GetProduct(
new
ObjectId(id));
if
(product ==
null
)
{
return
NotFound();
}
return
new
ObjectResult(product);
}
[HttpPost]
public
IActionResult Post([FromBody]Product p)
{
objds.Create(p);
return
new
HttpOkObjectResult(p);
}
[HttpPut(
"{id:length(24)}"
)]
public
IActionResult Put(
string
id, [FromBody]Product p)
{
var recId =
new
ObjectId(id);
var product = objds.GetProduct(recId);
if
(product ==
null
)
{
return
HttpNotFound();
}
objds.Update(recId, p);
return
new
OkResult();
}
[HttpDelete(
"{id:length(24)}"
)]
public
IActionResult Delete(
string
id)
{
var product = objds.GetProduct(
new
ObjectId(id));
if
(product ==
null
)
{
return
NotFound();
}
objds.Remove(product.Id);
return
new
OkResult();
}
}
}
|
The above Web API class uses DataAccess class for performing CRUD operations. The Web API class contains GET, POST, PUT and DELETE methods for Http operations.
Step 5: Open the launchSettings.json in the Properties folder and add the following settings in it:
"profiles"
: {
"IIS Express"
: {
"commandName"
:
"IISExpress"
,
"launchBrowser"
:
true
,
"launchUrl"
:
"api/Product"
,
"environmentVariables"
: {
"Hosting:Environment"
:
"Development"
}
}
|
This provides launchUrl to run the application in IIS Express.
Run the application in browser and the following result will be displayed:
To Test this we will make use of Fiddler tool. Open the fiddler tool and enter the following URL in it
Click on Execute button and the following result will be displayed
To Post the data, enter the following details in Fiddler
Click on Execute button and the data will be posted. Run the following command from the Mongo Command prompt
>db.Products.find({})
|
The following result will be displayed
Conclusion: Using Mongo C# Driver we can easily connect to the popular MongoDB database and perform CRUD operations. Using ASP.NET WebAPI, MongoDB data can be easily made available to various client apps for storing and reading data.