Entity Framework Code-First is the coolest thing since sliced bread, Windows Phone is the hottest thing since Tickle-Me-Elmo and OData is just too great
to ignore. As part of the Full Stack project, we wanted
to put them together, which turns out
to be pretty easy… once you know how. EF Code-First CTP5 is available now and there should be very few breaking changes in the release edition, which is due early in 2011. Note: EF Code-First evolved rapidly and many of the existing documents and blog posts which were written with earlier versions, may now be obsolete or at least misleading. Code-First? With traditional Entity Framework you start with a database and from that you generate “entities” – classes that bridge between the relational database and your object oriented program. With Code-First (Magic-Unicorn) (see Hanselman’s write up and this later write up by Scott Guthrie) the Entity Framework looks at classes you created and says “if I had created these classes, the database would have
to have looked like this…” and creates the database for you! By deriving your entity collections from DbSet and exposing them via a class that derives from DbContext, you "turn on" database backing for your POCO with a minimum of code and no hidden designer or configuration files. POCO == Plain Old CLR Objects Your entity objects can be used throughout your applications - in web applications, console applications, Silverlight and Windows Phone applications, etc. In our case, we'll want
to read and update data from a Windows Phone client application, so we'll expose the entities through a DataService and hook the Windows Phone client application
to that data via proxies. Piece of Pie. Easy as cake. The Demo Architecture
To see this at work, we’ll create an ASP.NET/MVC application which will act as the host for our Data Service. We’ll create an incredibly simple data layer using EF Code-First on top of SQLCE4 and we’ll expose the data in a WCF Data Service using the oData protocol. Our Windows Phone 7 client will instantiate the data context via a URI and load the data asynchronously. Setting up the Server project with MVC 3, EF Code First, and SQL CE 4 Create a new application of type ASP.NET MVC 3 and name it DeadSimpleServer. We need
to add the latest SQLCE4 and Entity Framework Code First CTP's
to our project. Fortunately, NuGet makes that really easy. Open the Package Manager Console (View / Other Windows / Package Manager Console) and type in "Install-Package EFCodeFirst.SqlServerCompact" at the PM> command prompt. Since NuGet handles dependencies for you, you'll see that it installs everything you need
to use Entity Framework Code First in your project. PM> install-package EFCodeFirst.SqlServerCompact
'SQLCE (= 4.0.8435.1)' not installed. Attempting
to retrieve dependency from source...
Done
'EFCodeFirst (= 0.8)' not installed. Attempting
to retrieve dependency from source...
Done
'WebActivator (= 1.0.0.0)' not installed. Attempting
to retrieve dependency from source...
Done
You are downloading SQLCE from Microsoft, the license agreement
to which is available at http://173.203.67.148/licenses/SQLCE/EULA_ENU.rtf. Check the package for additional dependencies, which may come with their own license agreement(s). Your use of the package and dependencies constitutes your acceptance of their license agreements. If you do not accept the license agreement(s), then delete the relevant components from your device.
Successfully installed 'SQLCE 4.0.8435.1'
You are downloading EFCodeFirst from Microsoft, the license agreement
to which is available at http://go.microsoft.com/fwlink/?LinkID=206497. Check the package for additional dependencies, which may come with their own license agreement(s). Your use of the package and dependencies constitutes your acceptance of their license agreements. If you do not accept the license agreement(s), then delete the relevant components from your device.
Successfully installed 'EFCodeFirst 0.8'
Successfully installed 'WebActivator 1.0.0.0'
You are downloading EFCodeFirst.SqlServerCompact from Microsoft, the license agreement
to which is available at http://173.203.67.148/licenses/SQLCE/EULA_ENU.rtf. Check the package for additional dependencies, which may come with their own license agreement(s). Your use of the package and dependencies constitutes your acceptance of their license agreements. If you do not accept the license agreement(s), then delete the relevant components from your device.
Successfully installed 'EFCodeFirst.SqlServerCompact 0.8'
Successfully added 'SQLCE 4.0.8435.1'
to EfCodeFirst-CTP5
Successfully added 'EFCodeFirst 0.8'
to EfCodeFirst-CTP5
Successfully added 'WebActivator 1.0.0.0'
to EfCodeFirst-CTP5
Successfully added 'EFCodeFirst.SqlServerCompact 0.8'
to EfCodeFirst-CTP5
Note: We're using SQLCE 4 with Entity Framework here because they work really well together from a development scenario, but you can of course use Entity Framework Code First with other databases supported by Entity framework.
Creating The Model using EF Code First
Now we can create our model class. Right-click the Models folder and select Add/Class. Name the Class Person.cs and add the following code:
using System.Data.Entity;
namespace DeadSimpleServer.Models
{
public class Person
{
public int ID { get; set; }
public string Name { get; set; }
}
public class PersonContext : DbContext
{
public DbSet<Person> People { get; set; }
}
}
Notice that the entity class Person has no special interfaces or base class. There's nothing special needed
to make it work - it's just a POCO. The context we'll use
to access the entities in the application is called PersonContext, but you could name it anything you wanted. The important thing is that it inherits DbContext and contains one or more DbSet which holds our entity collections.
Adding Seed Data
We need some testing data
to expose from our service. The simplest way
to get that into our database is
to modify the CreateCeDatabaseIfNotExists class in AppStart_SQLCEEntityFramework.cs by adding some seed data
to the Seed method:
protected virtual void Seed( TContext context )
{
var personContext = context as PersonContext;
personContext.People.Add( new Person { ID = 1, Name = "George Washington" } );
personContext.People.Add( new Person { ID = 2, Name = "John Adams" } );
personContext.People.Add( new Person { ID = 3, Name = "Thomas Jefferson" } );
personContext.SaveChanges();
}
The CreateCeDatabaseIfNotExists class name is pretty self-explanatory - when our DbContext is accessed and the database isn't found, a new one will be created and populated with the data in the Seed method. There's one more step
to make that work - we need
to uncomment a line in the Start method at the top of of the AppStart_SQLCEEntityFramework class and set the context name, as shown here,
public static class AppStart_SQLCEEntityFramework {
public static void Start() {
DbDatabase.DefaultConnectionFactory = new SqlCeConnectionFactory("System.Data.SqlServerCe.4.0");
// Sets the default database initialization code for working with Sql Server Compact databases
// Uncomment this line and replace CONTEXT_NAME with the name of your DbContext if you are
// using your DbContext
to create and manage your database
DbDatabase.SetInitializer(new CreateCeDatabaseIfNotExists<PersonContext>());
}
}
Now our database and entity framework are set up, so we can expose data via WCF Data Services.
Note: This is a bare-bones implementation with no administration screens. If you'd like
to see how those are added, check out The Full Stack screencast series.
Creating the oData Service using WCF Data Services
Add a new WCF Data Service
to the project (right-click the project / Add New Item / Web / WCF Data Service).
We’ll be exposing all the data as read/write. Remember
to reconfigure
to control and minimize access as appropriate for your own application.
Open the code behind for your service. In our case, the service was called PersonTestDataService.svc so the code behind class file is PersonTestDataService.svc.cs.
using System.Data.Services;
using System.Data.Services.Common;
using System.ServiceModel;
using DeadSimpleServer.Models;
namespace DeadSimpleServer
{
[ServiceBehavior( IncludeExceptionDetailInFaults = true )]
public class PersonTestDataService : DataService<PersonContext>
{
// This method is called only once
to initialize service-wide policies.
public static void InitializeService( DataServiceConfiguration config )
{
config.SetEntitySetAccessRule( "*", EntitySetRights.All );
config.DataServiceBehavior.MaxProtocolVersion = DataServiceProtocolVersion.V2;
config.UseVerboseErrors = true;
}
}
}
We're enabling a few additional settings
to make it easier
to debug if you run into trouble. The ServiceBehavior attribute is set
to include exception details in faults, and we're using verbose errors. You can remove both of these when your service is working, as your public production service shouldn't be revealing exception information.
You can view the output of the service by running the application and browsing
to http://localhost:[portnumber]/PersonTestDataService.svc/:
<service xml:base="http://localhost:49786/PersonTestDataService.svc/" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:app="http://www.w3.org/2007/app" xmlns="http://www.w3.org/2007/app">
<workspace>
<atom:title>Default</atom:title>
<collection href="People">
<atom:title>People</atom:title>
</collection>
</workspace>
</service>
This indicates that the service exposes one collection, which is accessible by browsing
to http://localhost:[portnumber]/PersonTestDataService.svc/People
<?xml version="1.0" encoding="iso-8859-1" standalone="yes"?>
<feed xml:base=http://localhost:49786/PersonTestDataService.svc/
xmlns:d="http://schemas.microsoft.com/ado/2007/08/dataservices"
xmlns:m="http://schemas.microsoft.com/ado/2007/08/dataservices/metadata"
xmlns="http://www.w3.org/2005/Atom">
<title type="text">People</title>
<id>http://localhost:49786/PersonTestDataService.svc/People</id>
<updated>2010-12-29T01:01:50Z</updated>
<link rel="self" title="People" href="People" />
<entry>
<id>http://localhost:49786/PersonTestDataService.svc/People(1)</id>
<title type="text"></title>
<updated>2010-12-29T01:01:50Z</updated>
<author>
<name />
</author>
<link rel="edit" title="Person" href="People(1)" />
<category term="DeadSimpleServer.Models.Person"
scheme="http://schemas.microsoft.com/ado/2007/08/dataservices/scheme" />
<content type="application/xml">
<m:properties>
<d:ID m:type="Edm.Int32">1</d:ID>
<d:Name>George Washington</d:Name>
</m:properties>
</content>
</entry>
<entry>
...
</entry>
</feed>
Let's recap what we've done so far.
But enough with services and XML - let's get this into our Windows Phone client application.
Creating the DataServiceContext for the Client
Use the latest DataSvcUtil.exe from http://odata.codeplex.com. As of today, that's in this download: http://odata.codeplex.com/releases/view/54698
You need
to run it with a few options:
/uri - This will point
to the service URI. In this case, it's http://localhost:59342/PersonTestDataService.svc Pick up the port number from your running server (e.g., the server formerly known as Cassini).
/out - This is the DataServiceContext class that will be generated. You can name it whatever you'd like.
/Version - should be set
to 2.0
/DataServiceCollection - Include this flag
to generate collections derived from the DataServiceCollection base, which brings in all the ObservableCollection goodness that handles your INotifyPropertyChanged events for you.
Here's the console session from when we ran it:
<ListBox
x:Name="MainListBox"
Margin="0,0,-12,0"
ItemsSource="{Binding}"
SelectionChanged="MainListBox_SelectionChanged">
Next,
to keep things simple, change the Binding on the two TextBlocks within the DataTemplate
to Name and ID,
<ListBox
x:Name="MainListBox"
Margin="0,0,-12,0"
ItemsSource="{Binding}"
SelectionChanged="MainListBox_SelectionChanged">
<ListBox.ItemTemplate>
<DataTemplate>
<StackPanel
Margin="0,0,0,17"
Width="432">
<TextBlock
Text="{Binding Name}"
TextWrapping="Wrap"
Style="{StaticResource PhoneTextExtraLargeStyle}" />
<TextBlock
Text="{Binding ID}"
TextWrapping="Wrap"
Margin="12,-6,12,0"
Style="{StaticResource PhoneTextSubtleStyle}" />
</StackPanel>
</DataTemplate>
</ListBox.ItemTemplate>
</ListBox>
Getting The Context
In the code-behind you’ll first declare a
member variable
to hold the context from the Entity Framework. This is named using convention over configuration.
The db type is Person and the context is of type PersonContext, You initialize it by providing the URI, in this case using the URL obtained from the Cassini web server,
PersonContext context =
new PersonContext(
new Uri( "http://localhost:49786/PersonTestDataService.svc/" ) );
Create a second
member variable of type DataServiceCollection<Person> but do not initialize it,
DataServiceCollection<Person> people;
In the constructor you’ll initialize the DataServiceCollection using the PersonContext,
public MainPage()
{
InitializeComponent();
people = new DataServiceCollection<Person>( context );
Finally, you’ll load the people collection using the LoadAsync method, passing in the fully specified URI for the People collection in the web service,
people.LoadAsync(
new Uri(
"http://localhost:49786/PersonTestDataService.svc/People" ) );
Note that this method runs asynchronously and when it is finished the people collection is already populated. Thus, since we didn’t need or want
to override any of the behavior we don’t implement the LoadCompleted.
You can use the LoadCompleted event if you need
to do any other UI updates, but you don't need
to. The final code is as shown below:
using System;
using System.Data.Services.Client;
using System.Windows;
using System.Windows.Controls;
using DeadSimpleServer.Models;
using Microsoft.Phone.Controls;
namespace WindowsPhoneODataTest
{
public partial class MainPage : PhoneApplicationPage
{
PersonContext context = new PersonContext(
new Uri( "http://localhost:49786/PersonTestDataService.svc/" ) );
DataServiceCollection<Person> people;
// Constructor
public MainPage()
{
InitializeComponent();
// Set the data context of the listbox control
to the sample data
// DataContext = App.ViewModel;
people = new DataServiceCollection<Person>( context );
people.LoadAsync(
new Uri( "http://localhost:49786/PersonTestDataService.svc/People" ) );
DataContext = people;
this.Loaded += new RoutedEventHandler( MainPage_Loaded );
}
// Handle selection changed on ListBox
private void MainListBox_SelectionChanged( object sender, SelectionChangedEventArgs e )
{
// If selected index is -1 (no selection) do nothing
if ( MainListBox.SelectedIndex == -1 )
return;
// Navigate
to the new page
NavigationService.Navigate(
new Uri( "/DetailsPage.xaml?selectedItem="
+ MainListBox.SelectedIndex, UriKind.Relative ) );
// Reset selected index
to -1 (no selection)
MainListBox.SelectedIndex = -1;
}
// Load data for the ViewModel Items
private void MainPage_Loaded( object sender, RoutedEventArgs e )
{
if ( !App.ViewModel.IsDataLoaded )
{
App.ViewModel.LoadData();
}
}
}
}
With people populated we can set it as the DataContext and run the application; you’ll find that the Name and ID are displayed in the list on the Mainpage. Here's how the pieces in the client fit together:
Complete source code available here
