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
