Entity Framework
Code First is a lightweight way to "turn on" data access for a simple CLR class. As
the name implies,
the intended use is that you're writing
the code first and thinking about
the database later. However, I really like
the Entity Framework
Code First works, and I want to use it in existing projects and projects with pre-existing databases. For example, MVC Music Store comes with a SQL Express database that's pre-loaded with a catalog of music (including genres, artists, and songs), and while it may eventually make sense to load that seed data from a different source, for
the MVC 3 release we wanted to keep using
the existing database. While I'm not getting
the full benefit of
Code First - writing
code which drives
the database schema - I can still benefit from
the simplicity of
the lightweight
code approach. Scott Guthrie blogged about how to use entity framework with an existing database, looking at how you can override
the Entity Framework
Code First conventions so that it can work with a database which was created following other conventions. That gives you
the information you need to create
the model classes manually. However, it turns out that with Entity Framework 4 CTP 5, there's a way to generate
the model classes from
the database schema. Once
the grunt work is done, of course, you can go in and modify
the model classes as you'd like, but you can save
the time and frustration of figuring out things like mapping SQL database types to .NET types. Note that this template requires Entity Framework 4 CTP 5 or later. You can install EF 4 CTP 5 here. Step One: Generate an EF Model from your existing database
The code generation system in Entity Framework works from a model. You can add a model to your existing project and delete it when you're done, but I think it's simpler to just spin up a separate project to generate
the model classes. When you're done, you can delete
the project without affecting your application, or you may choose to keep it around in case you have other database schema updates which require model changes. I chose to add
the Model classes to
the Models folder of a new MVC 3 application. Right-click
the folder and select "Add / New Item..." Next, select ADO.NET Entity Data Model from
the Data Templates list, and name it whatever you want (the name is unimportant). Next, select "Generate from database." This is important - it's what kicks off
the next few steps, which read your database's schema. Now it's time to point
the Entity Data Model Wizard at your existing database. I'll assume you know how to find your database - if not, I covered that a bit in
the MVC Music Store tutorial section on Models and Data. Select your database, uncheck
the "Save entity connection settings in Web.config" (since we won't be using them within
the application), and click Next. Now you can select
the database objects you'd like modeled. I just selected all tables and clicked Finish. And there's your model. If you want, you can make additional changes here before going on to generate
the code. Step Two: Add
the DbContext Generator Like most
code generation systems in Visual Studio lately, Entity Framework uses T4 templates which allow for some control over how
the code is generated. K Scott Allen wrote a detailed article on T4 Templates and
the Entity Framework on MSDN recently, if you'd like to know more. Fortunately for us, there's already a template that does just what we need without any customization. Right-click a blank space in
the Entity Framework model surface and select "Add
Code Generation Item..." Select
the Code groupt in
the Installed Templates section and pick
the ADO.NET DbContext Generator. If you don't see this listed, make sure you've got EF 4 CTP 5 installed and that you're looking at
the Code templates group. Note that
the DbContext Generator template is similar to
the EF POCO template which came out last year, but with "fix up"
code (unnecessary in EF
Code First) removed. As soon as you do this, you'll two terrifying Security Warnings - unless you click
the "Do not show this message again" checkbox
the first time. It will also be displayed (twice) every time you rebuild
the project, so I checked
the box and no immediate harm befell my computer (fingers crossed!). Here's
the payoff: two templates (filenames ending with .tt) have been added to
the project, and they've generated
the code I needed.
The "MusicStoreEntities.Context.tt" template built a DbContext class which holds
the entity collections, and
the "MusicStoreEntities.tt" template build a separate class for each table I selected earlier. We'll customize them in
the next step. I recommend copying all
the generated .cs files into your application at this point, since accidentally rebuilding
the generation project will overwrite your changes if you leave them there. Step Three: Modify and use your POCO entity classes Note: I made a bunch of tweaks to my POCO classes after they were generated. You don't have to do any of this, but I think it's important that you can - they're your classes, and EF
Code First respects that. Modify them as you need for your application, or don't.
The Context class derives from DbContext, which is what turns on
the EF
Code First features. It holds a DbSet for each entity. Think of DbSet as a simple List, but with Entity Framework features turned on. //------------------------------------------------------------------------------
// <auto-generated>
// This
code was generated from a template.
//
// Changes to this file may cause incorrect behavior and will be lost if
//
the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
namespace EF_CodeFirst_From_Existing_Database.Models
{
using System;
using System.Data.Entity;
public partial class Entities : DbContext
{
public Entities()
: base("name=Entities")
{
}
public DbSet<Album> Albums { get; set; }
public DbSet<Artist> Artists { get; set; }
public DbSet<Cart> Carts { get; set; }
public DbSet<Genre> Genres { get; set; }
public DbSet<OrderDetail> OrderDetails { get; set; }
public DbSet<Order> Orders { get; set; }
}
}
It's a pretty lightweight class as generated, so I just took out
the comments, set
the namespace, removed
the constructor, and formatted it a bit. Done.
If I wanted, though, I could have added or removed DbSets, overridden conventions, etc.
using System.Data.Entity;
namespace MvcMusicStore.Models
{
public class MusicStoreEntities : DbContext
{
public DbSet Albums { get; set; }
public DbSet Genres { get; set; }
public DbSet Artists { get; set; }
public DbSet Carts { get; set; }
public DbSet Orders { get; set; }
public DbSet OrderDetails { get; set; }
}
}
Next, it's time to look at
the individual classes. Some of mine were pretty simple - for
the Cart class, I just need to remove
the header and clean up
the namespace.
//------------------------------------------------------------------------------
//
// This
code was generated from a template.
//
// Changes to this file may cause incorrect behavior and will be lost if
//
the code is regenerated.
//
//------------------------------------------------------------------------------
namespace EF_CodeFirst_From_Existing_Database.Models
{
using System;
using System.Collections.Generic;
public partial class Cart
{
// Primitive properties
public int RecordId { get; set; }
public string CartId { get; set; }
public int AlbumId { get; set; }
public int Count { get; set; }
public System.DateTime DateCreated { get; set; }
// Navigation properties
public virtual Album Album { get; set; }
}
}
I did a bit more customization on
the Album class. Here's what was generated:
//------------------------------------------------------------------------------
//
// This
code was generated from a template.
//
// Changes to this file may cause incorrect behavior and will be lost if
//
the code is regenerated.
//
//------------------------------------------------------------------------------
namespace EF_CodeFirst_From_Existing_Database.Models
{
using System;
using System.Collections.Generic;
public partial class Album
{
public Album()
{
this.Carts = new HashSet();
this.OrderDetails = new HashSet();
}
// Primitive properties
public int AlbumId { get; set; }
public int GenreId { get; set; }
public int ArtistId { get; set; }
public string Title { get; set; }
public decimal Price { get; set; }
public string AlbumArtUrl { get; set; }
// Navigation properties
public virtual Artist Artist { get; set; }
public virtual Genre Genre { get; set; }
public virtual ICollection Carts { get; set; }
public virtual ICollection OrderDetails { get; set; }
}
}
I removed
the header, changed
the namespace, and removed some of
the navigation properties. One nice thing about EF
Code First is that you don't have to have a property for each database column or foreign key. In
the Music Store sample, for instance, we build
the app up using
code first and start with just a few columns, adding in fields and navigation properties as
the application needs them. EF
Code First handles
the columsn we've told it about and doesn't complain about
the others. Here's
the basic class:
using System.ComponentModel;
using System.ComponentModel.DataAnnotations;
using System.Web.Mvc;
using System.Collections.Generic;
namespace MvcMusicStore.Models
{
public class Album
{
public int AlbumId { get; set; }
public int GenreId { get; set; }
public int ArtistId { get; set; }
public string Title { get; set; }
public decimal Price { get; set; }
public string AlbumArtUrl { get; set; }
public virtual Genre Genre { get; set; }
public virtual Artist Artist { get; set; }
public virtual List OrderDetails { get; set; }
}
}
It's my class, not Entity Framework's, so I'm free to do what I want with it. I added a bunch of MVC 3 annotations for scaffolding and validation support, as shown below:
using System.ComponentModel;
using System.ComponentModel.DataAnnotations;
using System.Web.Mvc;
using System.Collections.Generic;
namespace MvcMusicStore.Models
{
[Bind(Exclude = "AlbumId")]
public class Album
{
[ScaffoldColumn(false)]
public int AlbumId { get; set; }
[DisplayName("Genre")]
public int GenreId { get; set; }
[DisplayName("Artist")]
public int ArtistId { get; set; }
[Required(ErrorMessage = "An Album Title is required")]
[StringLength(160)]
public string Title { get; set; }
[Required(ErrorMessage = "Price is required")]
[Range(0.01, 100.00,
ErrorMessage = "Price must be between 0.01 and 100.00")]
public decimal Price { get; set; }
[DisplayName("Album Art URL")]
[StringLength(1024)]
public string AlbumArtUrl { get; set; }
public virtual Genre Genre { get; set; }
public virtual Artist Artist { get; set; }
public virtual List<OrderDetail> OrderDetails { get; set; }
}
}
The end result was that I had working EF
Code First model
code for
the finished application. You can follow along through
the tutorial to see how I built up to
the finished model classes, starting with simple 2-3 property classes and building up to
the full working schema.
Thanks to Diego Vega (on
the Entity Framework team) for pointing me to
the DbContext template.
