MVC Application using EntityFramework Code-First approach Part4

Learning MVC : Part4
MVC Application using EntityFrameworkCode-First approach.
Introduction:
In our firstthree articles, we learnt a lot about MVC, starting fromdefinition to use, fromcreating an application to connecting
the MVC application with databaseusing different techniques.
In very last partof the series we learnt how to connect our MVC application with existing databaseusing Entity Framework.
Our this article will focus on connecting our MVC application with database using CodeFirstapproach i.e. one of the feature
Microsoft’s Entity Framework provides.
Our Roadmap:
Just to remind our full roadmap towards learning MVC,
Part1: Introduction to MVC architecture and Separation of Concerns.
Part 2: Creating MVC Application from scratch and connecting it with databaseusing LINQ to SQL.
Part 3: Connecting the MVC Application with the help of EntityFramework DB-Firstapproach.
Part 4: Connecting the MVC Applicationwiththe helpof EntityFramework Code-Firstapproach.
Part 5: Implementing Repository Pattern in MVC Application with EntityFramework.
Part 6: Implementing a generic Repository Pattern and Unit Of Work pattern in MVCApplication with EntityFramework.
Pre-requisites:
There are few pre-requisites beforewe start with the article,
1. We haverunning sample application that we created in third part of the article series.
2. We haveEntityFramework 4.1 packageor dll on our local file system.
3. We understand how MVCapplication is created.

Code-First Approach:
To achieve a domain driven design, Entity Framework introduced EF 4.1 Code First. In the CodeFirst approach, wefocus on
the domain design or entities/POCO classes first and create classes as per our model requirement. We do not have the
database of the application, rather wecreate databaseautomatically fromcode after defining our domain.The database
created perfectly matches with the domain we design, so we have to be very conscious and keen in designing our domain
model. Itfeels exciting to see databasecreated on the fly with the help of our entities and xml configuration, withouteven
opening databaseserver.
No matter, you arenot an expert in database, if you are a c# developer, justfocus on your model/class creation.
EntityFramework willtake headache of creating and managing databasefor you.
Procedure:
Step1: Open the MVCapplication that we created in Learning MVC-Part3 in your VisualStudio.

We can clearly see and remember whatwe used to connect our MVC application to databasewith the help of entity
framework, yes itwas edmx class and our Model.tt classes generated fromedmx classes.
Step2: We don’tneed existing data-base, so you can delete the already created database for our part 3 application (if
created).

Step3: We don’tneed edmx files now, so let’s clean our application, wipe out all these classes.Justdelete EFDataModel.edmx,
Model1.Context.tt and Model1.tt file. Now please do not run the application  , it will givecompile time errors , since we
were using those classes ;-), Our Solution will look like,
Our old solution had UserListclass in Models folder, I have only changed the name of the class for differentiating it with
previous application, and readability as was in firstpart.

Step4: As simple as that, justadd a class to your solution, and name it MVCDBContext.cs as shown in following image,
Step5: Justadd System.Data.Entity dll as a reference to the solution if not already added.
Step6: Usethe namespaceSystem.Data.Entity in our DBContext class, and inherit the added class fromDBContext class,

DbContext Class: According to msdn , DbContext class is conceptually similar to ObjectContext.To define,the
ObjectContext class is the part of the core EF API in the Microsoft.NET Framework 4 and this is our hero class that allows us to
performqueries, change tracking and update the databaseusing the strongly typed classes that represent our model(entity
class). The DbContext is a wrapper around ObjectContextthat exposes the most commonly used features of ObjectContext as
well as provides somesimpler “shortcuts” to tasks that are frequently used but complicated to code directly with

ObjectContext.Simplfied alternative to ObjectContext and is the primary object for interacting with a database using a specific
model.
Step7: Add a DBSet property to the DbContext class that we created,
public DbSet<User> Users { get; set; }
User, defined in angular brackets, is the model that we created in Models folder, so our MVCDBContext class looks like,
using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.Linq;
using System.Web;
using LearningMVC.Models;
namespace LearningMVC
{
public class MVCDBContext : DbContext
{
public DbSet<User> Users { get; set; }
}
}
That’s it, our 90% work is done .
DbSet property: It is a Simplified alternative to ObjectSetand is used to performCRUD operations against a specific type
fromthe model.
By default name of the DbContext class will be the name our databasethat will automatically be created, so be wiseto select
the name of context class, else it could be handled in web.config also.
The name of model will be the name of Table in database and properties of model will be the columns of the table.
Our Heroes:

Both DbContext and DbSet are our super heroes, in creating and dealing with databaseoperations, and make us far
abstracted, providing ease of useto us.
When we are working with DbContext, weare in real working with entity sets. DbSetrepresents a typed entity set that is used
to performcreate, read, update, and delete operations. We are not creating DbSetobjects and using them indepedently.
DbSet can be only used with DbContext.
Step8: Define a connection string in web.config file, you can removepreviously defined connection string,th new connection
string will somewhatlook like,

The name of the connection string will be the name of the DbContect that we defined , i.e. MVCDbContext.
Step8: Now we justhave to modify the access method in controllers,earlier, when we created application in third part, we
were accessing the context class fromthe modelcontext class that were generated fromedmx file.Edmx file was added having
reference to already created database.
But now the case is different, we don’t havea databasenow, we’ll access the table and columns using our MVCDBContext
class in controllers, so justchange following line of code used in Actions of earlier application,

var dbContext = new MVCEntities() ;
to
var dbContext = new MVCDBContext();
Job Done.
Just Hit F5, and You’ll see,
How does the application run, whereis the data base??? Dude, go back to your data base server, and check for database,

We see our data baseis created, with the name MVCDB, that’s the magic of EntityFramework.Nowwecan performall the
CRUD operations on this database, using our application. Justcreate a new user.

In databasewe see, user created.

By default, integer propert with ID in its name of model will be the primary key in the data base, in our caseUserId,or you can
define the primary key in the model too.
Conclusion:
Now we know how to play with EntityFramework to create databaseas per our domain model fromour code,wehave already
moved ahead to advanced concepts of MVC and Entity Framework.

When we see the definition of DbContext, it uses the terms Repository Pattern and Unit of Work Pattern,We’lldiscuss these
more in detail in my next article.
Happy Coding :-) .

MVC Application using EntityFramework Code-First approach Part4

Recommended

More Related Content

What's hot (20)

Viewers also liked (8)

Similar to MVC Application using EntityFramework Code-First approach Part4 (20)

More from Akhil Mittal (20)

MVC Application using EntityFramework Code-First approach Part4