14 Days Free Technical Video Training from WintellectNOW


Building a relational data model in ASP.NET MVC 3 w/EF Code First

Tags: ASP.NET, ASP.NET MVC, Razor, MVC, Entity Framework

Just about every application uses some sort of data model, and .NET developers have been using POCOs (Plain Old CLR Objects) for some time now. You can use either new or existing POCOs in MVC 3 applications and still take advantage of EF (Entity Framework), and in particular, EF's Code First feature. EF's Code First feature allows you to base both an application and a database from your data model. EF additionally carries features for database and model first development.

Data Models, ORMs & Entity Framework

As with most business apps of any type, data models are at the heart of an application. When developing ASP.NET MVC applications it's best to go with an ORM (Object-Relational Mapper) such as EF, as ORMs alleviate many pains in dealing with databases and their objects. Since MVC is extensible and pluggable, you also have the choice of using 3rd party or open source ORMs, for example, the widely used nHibernate.

That's where things can get complex, and that's where EF fits in with multiple strategies to help alleviate common pains in modeling. There are many ways you can model data to represent and manipulate it the way you need to, either visually with a designer, or by using code. EF supports these data access options:

  • Database first
    • You can use Visual Studio to connect to a data source and visually generate a data model from an existing database(s).
  • Model first
    • Using model first you can build brand new databases from models you've created using the designers in Visual Studio.
  • Code First
    • With code first, you start with your own POCOs, just add a small amount of code, and voilà, instant ORM.

In addition to these features, EF has more advanced features, such as a XML based schema mappings and fluent APIs. EF is flexible enough to cover the spectrum of applications from the smallest of web sites to enterprise applications.

Before coding EF classes, you must add a NuGet package reference to EntityFramework by selecting "Add Library Package Reference" from the Project menu, and before using SQL CE 4.0 you'll need to add a regular reference to the System.Data.SqlServerCe library.

Building the basic data model

Code First is a feature of EF that maps POCOs containing classes, relationships, data annotations, etc..., to database tables, columns, constraints, and relationships in physical databases. EF CF creates the database by examining the code in the data model, then building the corresponding physical database and its objects. You have the option to merge or drop/recreate any databases generated by EF Code First, and you can additionally seed the database with  data (coming in a later post).

Since the controller returns the model to the view, you can send validation information to the view by using Data Annotations. Data annotations are attributes that you can apply to a model to perform common types of validation at the property level, as shown below in two basic POCO classes.

public class Category
    public int Id { get; set; }
    [Required(ErrorMessage = "The product category is required.")]
    public string Name { get; set; }
public class Product
    public int Id { get; set; }
    [DisplayName("Delicious Treat")]
    [Required(ErrorMessage = "The product name field is required.")]
    public string Name { get; set; }
    [Required(ErrorMessage = "The product description field is required.")]
    public string Description { get; set; }
    [DisplayName("Sale Price")]
    [Required(ErrorMessage = "The Sale Price field is required.")]
    public decimal Price { get; set; }
    [DisplayName("Made fresh on")]
    [Required(ErrorMessage = "The Freshly Baked On field is required.")]
    public DateTime CreationDate { get; set; }
    [DisplayName("Don't Sell After")]
    [Required(ErrorMessage = "The Expiration Date field is required.")]
    public DateTime ExpirationDate { get; set; }
    [DisplayName("Qty Available")]
    [Required(ErrorMessage = "The Qty Available field is required.")]
    [Range(0, 120,ErrorMessage="The Qty Available must be between 0 and 120.")]
    public int QtyOnHand { get; set; }
    [DisplayName("Product Image")]
    public string ImageName { get; set; }

Now that you have a model, you can add a few lines of code to tell EF to generate the database for you, and even seed it with data if you want to. In order for EF to know what classes in a project it should use as a model to generate the database, you need to tap into two classes from the System.Data.Entity namespace:

  • DBContext class.
    • The DbContext is a lot like a connection, except it manages database connectivity for you automatically (i.e., no need to explicitly call open/close on connections). Additionally, there are many properties methods on the DbContext class to work directly with the model and/or database, such as the SaveChanges method or the ValidateEntity method.
  • DbSet class
    • This object knows how to deal with CRUD operations on the entity class itself (i.e., Category or Product), and works in tandem with the DbContext object to perform those operations.

A data model is not just a set of POCO classes, though. Models need a class to manage the POCOs, perform connection management, or other duties that an ORM would do. These management classes are often called a context or repository[1]. Rather than writing the database and connection management code yourself, you can take advantage of EF and receive features provided automatically by inheriting from the DbContext class in your repository class.

The DbContext also needs to know what POCO collections to work with. You can do this by adding properties of type DbSet<T> for each of your collection types, as the code below demonstrates.

public class FourthCoffeeWebContext : DbContext
    public DbSet<Category> Categories { get; set; }
    public DbSet<Product> Products { get; set; }

At this point, the two POCO classes and DbContext are all you need to see EF in action, and you can move onto running the application and generating the physical database.

Generating the database from the model

Assuming you have the controllers and views in place to perform CRUD operations on the Categories and Products collections, running the MVC application will create a SQL (Express or CE 4.0) database automatically for you. Of course, there's no data, just the schema, but the site and database are both up, running, and completely functional. Navigating to the create action on the products controller in a browser renders the create view like the one below (including validation!):


Once you save a product, the app takes you back to the listing of products, where you can see the results.


Although you can see the data on in the browser, you probably can't find the database in the Solution Explorer. Checking out the customary App_Data folder reveals nothing, and examining the Web.Config file comes up empty. Since EF could find no information about the database, it created a SQL Express[2] database with the a default name and path shown here:

C:\Program Files\Microsoft SQL Server\MSSQL10_50.SQLEXPRESS\MSSQL\DATA\FourthCoffee.Web.Models.FourthCoffeeWebContext.mdf.

If you want to name your database something different, modify the <connectionStrings> section of the Web.Config file to point to the preferred database name and location. This connection string connects to the \App_Data\bakery.sdf database.

  <add name="FourthCoffeeWebContext" connectionString="Data Source=|DataDirectory|bakery.sdf" 
  providerName="System.Data.SqlServerCe.4.0" />

By convention, the name of this connection string needs to match the name of your context/repository class, in this case, FourthCoffeeWebContext, so EF can identify the connection string to use. Notice that the connection string points to the data directory (App_Data) and it's a SQL CE 4.0 database. If you wish to use a different edition of SQL, feel free to change the connection string and provider name to point to other locations.

Once the changes are in place, run the application, enter some data, and return to Visual Studio where you can see the App_Data folder now contains the bakery.sdf database.


Since the option to drop and recreate the database exists, you can design your data model through code and tests to verify that it works in a repetitive cycle, so relating the classes and regenerating the database is easy.

Relating classes in the data model

The Category and Product classes relate to each other in a one-(zero or)many relationship. You can express this relationship in code by adding a property in the Category class to represent the collection of related products, as shown here:

public virtual ICollection<Product> Products { get; set; }

The Product class needs two lines of code, so you'll need to add the following properties below to the Product class.

public int CategoryId { get; set; }
public virtual Category Category { get; set; }

While the data model is complete, the code in controllers and views does not reflect the updates made to the model. The Edit and Create views associated with the Product need to include a dropdown of the categories, with the current product's category selected, similar to the code below:

<div class="editor-label">
<div class="editor-field">
    @Html.DropDownListFor(model => model.CategoryId, 
        .Select(option => new SelectListItem {
        Text = (option == null ? "None" : option.Name), 
        Value = option.Id.ToString(),
        Selected = (Model != null) && (option.Id == Model.CategoryId)
    }), "Choose...")
    @Html.ValidationMessageFor(model => model.CategoryId)

Since the view is counting on the controller to pass in a ViewBag.PossibleCategories, you'll now need to wire up the Create/Edit action methods of the Products controller so the view can use it. Just create a dynamic property on the ViewBag object and set it to the context's Categories property.

// the context variable is of type FourthCoffeeWebContext (Inherits from DbContext)
ViewBag.PossibleCategories = context.Categories;

Generating an app from the finished model

The application at run time produces 100% supported CRUD operations, but now with relational operations and validation as well. This is evident in the Product's Edit or Create view.


Note: Before running the application, you'll need to delete the database or you'll receive an error message.


MVC with Entity Framework Code First enables you to rapidly build sites with easy to understand data models.


Code First w/existing DB

Code First


[1] Dear purists: I am not going to be pedantic about the repository pattern in this blog post.

[2] If you don't have SQL Express installed, you might get an error. If that's the case modify the web config to use SQL CE 4.0 instead, as it does not need to be installed.


  • Balakrishna said


    It is nice post thank you for the information,

    I have a small query regarding a scenario where i have one more field in the Category; i.e. a Desc field which is also decorated with the [Required] annotation,

    Now when i am running the products Page, I am getting Error Message for the Field of desc in the Products Page Validation Summary.

    can you please help with this scenario, please let me know if you want me to send a Complete Sample project to validate.

    please do the needful.

    thanks & regards

  • Rachel said


    You can toggle the @ValidationSummary(true/false) in your view. That controls the summary list display.

  • Java Whiz said

    Thank you so much for this post. I was doing the dropdownlist differently but was running into issues when I wanted to have the dropdownlist text value combine two db columns instead of the standard one. Your method remedied that issue. Cool!

  • James Skemp said

    Is there any particular reason you recommend using a normal reference to System.Data.SqlServerCe instead of using Nuget to add the reference?

    Initially when I was playing with this yesterday I was running into issues, after adding the reference via Nuget, but it turned out my particular issue was because EF Code First and Database First don't get along. (Although it's unfortunate I didn't see this workaround - http://blogs.msdn.com/b/wriju/archive/2011/05/17/using-ado-net-ef-4-1-code-first-with-existing-database.aspx - before I reverted all my changes back.)

  • Rachel said


    It's just a force of habit for me to add a Reference rather get it through Nuget in this case. There's not really any difference in the end result (i.,e, a reference).

  • Jeswin James said

    Gr8 Article,

    Can you please explain me the following

    ViewBag.PossibleCategories = context.Categories;
    //How should i be using this.

    Its giving me problem with the DropDownList

    error msg:

    {"Value cannot be null.\r\nParameter name: source"}

  • Rachel said


    That is how you should be using it in the controller. Be sure the context and Categories aren't null before trying to assign a value to it.

  • moncler said

    As with most business apps of any type, data models are at the heart of an application. When developing ASP.NET MVC applications it's best to go with an ORM (Object-Relational Mapper) such as EF, as ORMs alleviate many pains in dealing with databases and their objects. Since MVC is extensible and pluggable, you also have the choice of using 3rd party or

  • Nick Lachey said

    Nice post. Here’s a tutorial that shows how you can easily build an online database-driven web application with a parent-child table relationship, without codinghttp://blog.caspio.com/web-database/creating-one-to-many-relational-datapages/

  • Classie said

    Hi, thanks for the awesome post. I got this working for create and edit. Is it possible to use the same concept and instead having it for @Html.DropDownListFor can one use the same for use in @Html.DisplayFor so that on my Index view I do not have an Id but a name. Thanks

  • Rachel said


    You can, and you can do it within the DropDownList or DropDownListFor - there are severl overloads to those that will allow you to hide the ID and show the friendly text to the user.

Comments have been disabled for this content.