This week the data team released the CTP5 build of the new Entity Framework Code-First library. EF Code-First enables a pretty sweet code-centric development workflow for working with data. It enables you to: Develop without ever having
to open a designer or define an XML mapping file Define model objects by simply writing “plain old classes” with no base classes required Use a “convention over configuration” approach that enables database persistence without explicitly configuring anything Optionally override the convention-based persistence and use a fluent code API
to fully customize the persistence mapping I’m a big fan of the EF Code-First approach, and wrote several blog posts about it this summer: Code-First Development with Entity Framework 4 (July 16th) EF Code-First: Custom Database Schema Mapping (July 23rd) Using EF Code-First with an Existing Database (August 3rd) Today’s new CTP5 release delivers several nice improvements over the CTP4 build, and will be the last preview build of Code First before the final release of it. We will ship the final EF Code First release in the first quarter of next year (Q1 of 2011). It works with all .NET application types (including both ASP.NET Web Forms and ASP.NET MVC projects). Installing EF Code First You can install and use EF Code First CTP5 using one of two ways: Approach 1) By downloading and running a setup program. Once installed you can reference the EntityFramework.dll assembly it provides within your projects. or: Approach 2) By using the NuGet Package Manager within Visual Studio
to download and install EF Code First within a project.
To do this, simply bring up the NuGet Package Manager Console within Visual Studio (View->Other Windows->Package Manager Console) and type “Install-Package EFCodeFirst”: Typing “Install-Package EFCodeFirst” within the Package Manager Console will cause NuGet
to download the EF Code First package, and add it
to your current project: Doing this will automatically add a reference
to the EntityFramework.dll assembly
to your project: NuGet enables you
to have EF Code First setup and ready
to use within seconds. When the final release of EF Code First ships you’ll also be able
to just type “Update-Package EFCodeFirst”
to update your existing projects
to use the final release. EF Code First Assembly and Namespace The CTP5 release of EF Code First has an updated assembly name, and new .NET namespace: Assembly Name: EntityFramework.dll Namespace: System.Data.Entity These names match what we plan
to use for the final release of the library. Nice New CTP5 Improvements The new CTP5 release of EF Code First contains a bunch of nice improvements and refinements. Some of the highlights include: Better support for Existing Databases Built-in Model-Level Validation and DataAnnotation Support Fluent API Improvements Pluggable Conventions Support New Change Tracking API Improved Concurrency Conflict Resolution Raw SQL Query/Command Support The rest of this blog post contains some more details about a few of the above changes. Better Support for Existing Databases EF Code First makes it really easy
to create model layers that work against existing databases. CTP5 includes some refinements that further streamline the developer workflow for this scenario. Below are the steps
to use EF Code First
to create a model layer for the Northwind sample database: Step 1: Create Model Classes and a DbContext class Below is all of the code necessary
to implement a simple model layer using EF Code First that goes against the Northwind database: EF Code First enables you
to use “POCO” – Plain Old CLR Objects –
to represent entities within a database. This means that you do not need
to derive model classes from a base class, nor implement any interfaces or data persistence attributes on them. This enables the model classes
to be kept clean, easily testable, and “persistence ignorant”. The Product and Category classes above are examples of POCO model classes. EF Code First enables you
to easily connect your POCO model classes
to a database by creating a “DbContext” class that exposes public properties that map
to the tables within a database. The Northwind class above illustrates how this can be done. It is mapping our Product and Category classes
to the “Products” and “Categories” tables within the database. The properties within the Product and Category classes in turn map
to the columns within the Products and Categories tables – and each instance of a Product/Category
object maps
to a row within the tables. The above code is all of the code required
to create our model and data access layer! Previous CTPs of EF Code First required an additional step
to work against existing databases (a call
to Database.Initializer<Northwind>(null)
to tell EF Code First
to not create the database) – this step is no longer required with the CTP5 release. Step 2: Configure the Database Connection String We’ve written all of the code we need
to write
to define our model layer. Our last step before we use it will be
to setup a connection-string that connects it with our database.
To do this we’ll add a “Northwind” connection-string
to our web.config file (or App.Config for client apps) like so: <connectionStrings> <add name="Northwind" connectionString="data source=.\SQLEXPRESS;Integrated Security=SSPI;AttachDBFilename=|DataDirectory|\northwind.mdf;User Instance=true" providerName="System.Data.SqlClient" /> </connectionStrings>
EF “code first” uses a convention where DbContext classes by default look for a connection-string that has the same name as the context class. Because our DbContext class is called “Northwind” it by default looks for a “Northwind” connection-string
to use. Above our Northwind connection-string is configured
to use a local SQL Express database (stored within the \App_Data directory of our project). You can alternatively point it at a remote SQL Server.
Step 3: Using our Northwind Model Layer
We can now easily query and update our database using the strongly-typed model layer we just built with EF Code First.
The code example below demonstrates how
to use
LINQ to query for products within a specific product category. This query returns back a sequence of strongly-typed Product objects that match the search criteria:
The code example below demonstrates how we can retrieve a specific Product
object, update two of its properties, and then save the changes back
to the database:
EF Code First handles all of the change-tracking and data persistence work for us, and allows us
to focus on our application and business logic as opposed
to having
to worry about data access plumbing.
Built-in Model Validation
EF Code First allows you
to use any validation approach you want when implementing business rules with your model layer. This enables a great deal of flexibility and power.
Starting with this week’s CTP5 release, EF Code First also now includes built-in support for both the DataAnnotation and IValidatorObject validation support built-into .NET 4. This enables you
to easily implement validation rules on your models, and have these rules automatically be enforced by EF Code First whenever you save your model layer. It provides a very convenient “out of the box” way
to enable validation within your applications.
Applying DataAnnotations
to our Northwind Model
The code example below demonstrates how we could add some declarative validation rules
to two of the properties of our “Product” model:
We are using the [Required] and [Range] attributes above. These validation attributes live within the System.ComponentModel.DataAnnotations namespace that is built-into .NET 4, and can be used independently of EF. The error messages specified on them can either be explicitly defined (like above) – or retrieved from resource files (which makes localizing applications easy).
Validation Enforcement on SaveChanges()
EF Code-First (starting with CTP5) now automatically applies and enforces DataAnnotation rules when a model
object is updated or saved. You do not need
to write any code
to enforce this – this support is now enabled by default.
This new support means that the below code – which violates our above rules – will automatically throw an exception when we call the “SaveChanges()” method on our Northwind DbContext:
The DbEntityValidationException that is raised when the SaveChanges() method is invoked contains a “EntityValidationErrors” property that you can use
to retrieve the list of all validation errors that occurred when the model was trying
to save. This enables you
to easily guide the user on how
to fix them. Note that EF Code-First will abort the entire transaction of changes if a validation rule is violated – ensuring that our database is always kept in a valid, consistent state.
EF Code First’s validation enforcement works both for the built-in .NET DataAnnotation attributes (like Required, Range, RegularExpression, StringLength, etc), as well as for any custom validation rule you create by sub-classing the System.ComponentModel.DataAnnotations.ValidationAttribute base class.
UI Validation Support
A lot of our UI frameworks in .NET also provide support for DataAnnotation-based validation rules. For example, ASP.NET MVC, ASP.NET Dynamic Data, and Silverlight (via WCF RIA Services) all provide support for displaying client-side validation UI that honor the DataAnnotation rules applied
to model objects.
The screen-shot below demonstrates how using the default “Add-View” scaffold template within an ASP.NET MVC 3 application will cause appropriate validation error messages
to be displayed if appropriate values are not provided:
ASP.NET MVC 3 supports both client-side and server-side enforcement of these validation rules. The error messages displayed are automatically picked up from the declarative validation attributes – eliminating the need for you
to write any custom code
to display them.
Keeping things DRY
The “DRY Principle” stands for “Do Not Repeat Yourself”, and is a best practice that recommends that you avoid duplicating logic/configuration/code in multiple places across your application, and instead specify it only once and have it apply everywhere.
EF Code First CTP5 now enables you
to apply declarative DataAnnotation validations on your model classes (and specify them only once) and then have the validation logic be enforced (and corresponding error messages displayed) across all applications scenarios – including within controllers, views, client-side scripts, and for any custom code that updates and manipulates model classes.
This makes it much easier
to build good applications with clean code, and
to build applications that can rapidly iterate and evolve.
Other EF Code First Improvements New
to CTP5
EF Code First CTP5 includes a bunch of other improvements as well. Below are a few short descriptions of some of them:
Fluent API Improvements
EF Code First allows you
to override an “OnModelCreating()” method on the DbContext class
to further refine/override the schema mapping rules used
to map model classes
to underlying database schema. CTP5 includes some refinements
to the ModelBuilder class that is passed
to this method which can make defining mapping rules cleaner and more concise. The ADO.NET Team blogged some samples of how
to do this here.
Pluggable Conventions Support
EF Code First CTP5 provides new support that allows you
to override the “default conventions” that EF Code First honors, and optionally replace them with your own set of conventions.
New Change Tracking API
EF Code First CTP5 exposes a new set of change tracking information that enables you
to access Original, Current & Stored values, and State (e.g. Added, Unchanged, Modified, Deleted). This support is useful in a variety of scenarios.
Improved Concurrency Conflict Resolution
EF Code First CTP5 provides better exception messages that allow access
to the affected
object instance and the ability
to resolve conflicts using current, original and database values.
Raw SQL Query/Command Support
EF Code First CTP5 now allows raw SQL queries and commands (including SPROCs)
to be executed via the SqlQuery and SqlCommand methods exposed off of the DbContext.Database property. The results of these method calls can be materialized into
object instances that can be optionally change-tracked by the DbContext. This is useful for a variety of advanced scenarios.
Full Data Annotations Support
EF Code First CTP5 now supports all standard DataAnnotations within .NET, and can use them both
to perform validation as well as
to automatically create the appropriate database schema when EF Code First is used in a database creation scenario.
Summary
EF Code First provides an elegant and powerful way
to work with data. I really like it because it is extremely clean and supports best practices, while also enabling solutions
to be implemented very, very rapidly. The code-only approach of the library means that model layers end up being flexible and easy
to customize.
This week’s CTP5 release further refines EF Code First and helps ensure that it will be really sweet when it ships early next year. I recommend using NuGet
to install and give it a try today. I think you’ll be pleasantly surprised by how awesome it is.
Hope this helps,
Scott
