Entity Framework: Code First and Migrations

Traditionally, Entity Framework has used a designer and XML files to define the conceptual and storage models. Now with Entity Framework Code First we can ditch the XML files and define the data model directly in code. This session will give an overview of all of the awesomeness that is Code First including Data Annotations, Fluent API, DbContext and the new Migrations feature. Be prepared for a fast moving and interactive session filled with great information on how to access your data.

Transcript

1. Richie Rump @Jorriss www.jorriss.net
3. • 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
5. • Code First Model • DbContext • Fluent API
6. • 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
7. • Code First Migrations • Data Annotations on non-public properties • Additional configuration file settings • Removal of EdmMetadata table • Bug Fixes
8. • Added –IgnoreChanges to enable CodeFirst against existing database. • More inevitable bug fixes.
9. Entity Framework 4.0 included with .Net 4.0 EF 4.1 - Code First & DbContext EF 4.2 – Bug Fixes EF 4.3 - Migrations EF 4.3.1 – Bug Fixes
10. Design First Code First New Database Existing Database Model First Create .edmx model in designer Generate DB from .edmx Classes auto-generate from .edmx Database First Reverse engineer .edmx model Classes auto-generate from .edmx Code First Define classes & mapping in code Database auto-created at runtime Code First Define classes & mapping in code Adapted from Programming Entity Framework: Code First by Julie Learman and Rowan Miller page 3.
11. Lovingly stolen from Programming Entity Framework: Code First by Julie Lerman and Rowan Miller page 9.
12. In a word: Nuget
13. • What does code look like? • How do we use it? • Stop! Demo time.
14. • Convention over configuration – Database naming – Primary Key • SQL Server Express – default database • dbContext Class
15. • 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
16. • 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
17. [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; } }
18. • 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
19. Data Annotations Fluent API modelBuilder.Entity<Order>() .Property(p => p.Id).HasColumnName("Order_ID"); [Column("Order_ID")] public int Id { get; set; }
20. • This time it will work…I swear!
21. • Expressed via the navigation properties in your classes public class Order { public int Id { get; set; } public OrderState State { get; set; } }
23. 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 Id { get; set; } public int OrderStateID { get; set; } public OrderState State { get; set; } } public class OrderState { public int Id { get; set; } }
25. 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 Person { public int PersonID { get; set; } ... public List<Order> Orders { get; set; } } public class Order { public int Id { get; set; } public int PersonID { get; set; } public virtual Person SalesPerson { get; set; } }
27. HasMany(p => p.Items).WithMany(t => t.Orders) .Map(m => { m.ToTable("Order_Item"); m.MapLeftKey("Order_ID"); m.MapRightKey("Item_ID"); }); public class Item { public int Id { get; set; } ... public List<Order> Orders { get; set; } } public class Order { public int Id { get; set; } ... public List<Item> Items { get; set; } }
28. • New way to interact with EF objects • Makes interaction with EF MUCH simpler • Encapsulates existing EF objects such as ObjectContext, ObjectSet and ObjectQuery
29. • DbContext – Provides facilities querying and persisting object changes. • DbSet – Represents an entity for CRUD operations • Change Tracker API and Validation API are other features
30. EFTestContext context = new EFTestContext(); var query = context.Orders .Where(c => c.PersonID == 22) .Include(c => c.State) .ToList(); List<Order> orders = context.Orders.ToList();
31. • Easy way to retrieve an object via the Primary Key. EFTestContext context = new EFTestContext(); Person p = context.People.Find(1);
32. EFTestContext context = new EFTestContext(); Person p = new Person { FirstName = "Testy", LastName = "User" }; context.People.Add(p); context.SaveChanges();
33. EFTestContext context = new EFTestContext(); Person p = context.People.Find(1); context.People.Remove(p); context.SaveChanges();
34. • 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
35. • To turn Migrations on • This creates a Migration folder in project • Creates Configuration.cs file • Creates __MigrationHistory system table in DB PM> Enable-Migrations
36. • “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> Add-Migration "Inital" -IgnoreChanges
37. • 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. PM> Update-Database
38. Y U NO DO DATABASE RIGHT?!?!?!!!
39. • 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
41. • 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
42. Richie Rump @Jorriss http://jorriss.net http://slideshare.net/jorriss http://dotnetmiami.com