dotNet Miami - June 21, 2012: Richie Rump: Entity Framework: Code First and Migrations

Richie Rump
@Jorriss
www.jorriss.net

• Object-Relational Mapping Framework
• Allows developers to retrieve database
data from an object model.
• Converts object data into relational data
• Uses your classes
• Generates SQL

• Code First Model
• DbContext
• Fluent API

• Bug Fixes
• Semantic Versioning
Because Entity Framework 4.2 is better
than:
Entity Framework 4.1 Service Pack 2
Update 1 Refresh Release To Web Pack

• Code First Migrations
• Data Annotations on non-public properties
• Additional configuration file settings
• Removal of EdmMetadata table
• Bug Fixes

• Added –IgnoreChanges to enable CodeFirst
against existing database.
• More inevitable bug fixes.

EF 4.3.1 – Bug Fixes

EF 4.3 - Migrations

EF 4.2 – Bug Fixes

EF 4.1 - Code First & DbContext

Entity Framework 4.0
included with .Net 4.0

Design First Code First

Model First Code First
Create .edmx model in designer Define classes & mapping in code
New Generate DB from .edmx Database auto-created at
Database Classes auto-generate from runtime
.edmx

Database First Code First
Reverse engineer .edmx model Define classes & mapping in code
Existing Classes auto-generate from
Database .edmx

Adapted from Programming Entity Framework: Code First by Julie Learman and Rowan Miller page 3.

Lovingly stolen from Programming Entity Framework: Code First by Julie Lerman and Rowan Miller page 9.

• What does code look like?
• How do we use it?
• Stop! Demo time.

• Convention over configuration
– Database naming
– Primary Key
• SQL Server Express – default database
• dbContext Class

• It’s not enough to use convention.
• Tells EF how to map the object model to the
database model.
• Place annotations directly against the
property in your class.
• System.ComponentModel.DataAnnotations

• Key – Defines a Primary Key
• Column – Defines DB column name
• Table – Defines table name for a class
• Required – Defines a Required DB field
• NotMapped – Property not in DB mapping
• MinLength() – Min length for a property
• MaximumLength() – Max length for property
• Range() – Defines a valid value range

[Table(“Product_Order")]
public class Order
{
[Key]
[Column("Order_ID")]
public int OrderId { get; set; }
public DateTime Date { get; set; }
public OrderState State { get; set; }
public string Item { get; set; }
[Range(1, 25)]
public int Quantity { get; set; }
[MinLength(3, ErrorMessage="What are you thinking?")]
[MaxLength(50, ErrorMessage="ERROR!! FAILZ!!!!")]
public string Name { get; set; }
[NotMapped]
public string Note { get; set; }
}

• Allows you to configure EF without polluting
your classes with annotations.
• Cleaner code
• Can have all EF mapping code in one file.
• Some things you can only do in the Fluent API

Data Annotations
[Column("Order_ID")]
public int Id { get; set; }

Fluent API
modelBuilder.Entity<Order>()
.Property(p => p.Id).HasColumnName("Order_ID");

• This time it will work…I swear!

• Expressed via the navigation properties in
your classes
public class Order
{
}

public class Order
{
public int OrderStateID { get; set; }
}

public class OrderState
{
}

public OrderConfiguration()
{
ToTable("Order");
Property(p => p.OrderStateID).HasColumnName("Order_State_ID");
HasRequired(p => p.State).WithMany()
.HasForeignKey(f => f.OrderStateID);
}

public class Order
{
public int PersonID { get; set; }
public virtual Person SalesPerson { get; set; }
}

public class Person
{
public int PersonID { get; set; }
...
public List<Order> Orders { get; set; }
}

public OrderConfiguration()
{
ToTable("Order");
Property(p => p.PersonID).HasColumnName("Person_ID");
HasRequired(p => p.SalesPerson).WithMany(t => t.Orders)
.HasForeignKey(f => f.PersonID);
}

public class Order
{
...
public List<Item> Items { get; set; }
}

public class Item
{
...
public List<Order> Orders { get; set; }
}

HasMany(p => p.Items).WithMany(t => t.Orders)
.Map(m =>
{
m.ToTable("Order_Item");
m.MapLeftKey("Order_ID");
m.MapRightKey("Item_ID");
});

• New way to interact with EF objects
• Makes interaction with EF MUCH simpler
• Encapsulates existing EF objects such as
ObjectContext, ObjectSet and ObjectQuery

• DbContext – Provides facilities querying and
persisting object changes.
• DbSet – Represents an entity for CRUD
operations
• Change Tracker API and Validation API are
other features

EFTestContext context = new EFTestContext();

var query = context.Orders
.Where(c => c.PersonID == 22)
.Include(c => c.State)
.ToList();

List<Order> orders = context.Orders.ToList();

• Easy way to retrieve an object via the Primary
Key.

Person p = context.People.Find(1);

Person p = new Person { FirstName = "Testy", LastName = "User" };
context.People.Add(p);
context.SaveChanges();

Person p = context.People.Find(1);
context.People.Remove(p);
context.SaveChanges();

• Migrations is a new way to generate database
changes automatically
• It’s controlled through PowerShell commands
• Can migrate forward or rollback DB changes.
• Migrations can be handled automatically. EF
will automatically apply change scripts

• To turn Migrations on

PM> Enable-Migrations

• This creates a Migration folder in project
• Creates Configuration.cs file
• Creates __MigrationHistory system table in DB

PM> Add-Migration "Inital" -IgnoreChanges

• “Initial” is the name of the migration
• The –IgnoreChanges switch tells EF to create an
empty migration. Use this if this is the first
migration and EF did not create the DB.
• Creates a cs file with the changes since the last
migration.
• Does not apply changes to DB.

PM> Update-Database

• Pushes the migration changes to the DB
• Use the –script switch to have EF create a SQL
script of the changes.
• Use –TargetMigration to determine end point for
DB. (Rollback/Forward)
• Be careful. I wouldn’t run against a production DB.

Y U NO DO DATABASE RIGHT?!?!?!!!

• Now in Release Candidate
• Install using Nuget
Install-Package EntityFramework –Pre
• ENUMS!
• Performance Improvements
• Spatial Data Types
• Table-Valued Functions
• Most features only in .Net 4.5

• Julie Lerman’s Blog
http://thedatafarm.com/blog/
• Rowan Miller’s Blog
http://romiller.com
• Arthur Vicker’s Blog
http://blog.oneunicorn.com
• #efhelp on twitter
• StackOverflow (of course)
• PluralSight – Julie Lerman’s EF videos

Richie Rump
@Jorriss
http://jorriss.net
http://dotnetmiami.com

dotNet Miami - June 21, 2012: Richie Rump: Entity Framework: Code First and Migrations

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to dotNet Miami - June 21, 2012: Richie Rump: Entity Framework: Code First and Migrations (20)

Recently uploaded (20)

dotNet Miami - June 21, 2012: Richie Rump: Entity Framework: Code First and Migrations

Editor's Notes