Last month we released the Beta of VS 2010 Service Pack 1 (SP1). You can learn more about the VS 2010 SP1 Beta from Jason Zander’s two blog posts about it, and from Scott Hanselman’s blog post that covers some of the new capabilities enabled with it. You can download and install the VS 2010 SP1 Beta here. Last week I blogged about the new Visual Studio support for IIS Express that we are adding with VS 2010 SP1.
In today’s post I’m going
to talk about the new VS 2010 SP1 tooling support for SQL CE, and walkthrough some of the cool scenarios it enables. SQL CE – What is it and why should you care? SQL CE is a free, embedded, database engine that enables easy database storage. No Database Installation Required SQL CE does not require you
to run a setup or install a database server
in order
to use it. You can simply copy the SQL CE binaries into the \bin directory of your
ASP.
NET application, and then your
web application can use it as a database engine. No setup or extra security permissions are required for it
to run. You do not need
to have an administrator account on the machine. Just copy your
web application onto any server and it will work. This is true even of medium-trust applications running
in a
web hosting environment. SQL CE runs in-memory within your
ASP.
NET application and will start-up when you first access a SQL CE database, and will automatically shutdown when your application is unloaded. SQL CE databases are stored as files that live within the \App_Data folder of your
ASP.
NET Applications. Works with Existing Data APIs SQL CE 4 works with existing .NET-based data APIs, and supports a SQL Server compatible query syntax. This means you can use existing data APIs like ADO.
NET, as well as use higher-level ORMs like Entity Framework and NHibernate with SQL CE. This enables you
to use the same data programming skills and data APIs you know today. Supports Development, Testing and Production Scenarios SQL CE can be used for development scenarios, testing scenarios, and light production usage scenarios. With the SQL CE 4 release we’ve done the engineering work
to ensure that SQL CE won’t crash or deadlock when used
in a multi-threaded server scenario (like
ASP.NET). This is a big change from previous releases of SQL CE – which were designed for client-only scenarios and which explicitly blocked running
in web-server environments. Starting with SQL CE 4 you can use it
in a web-server as well. There are no license restrictions with SQL CE. It is also totally free. Easy Migration
to SQL Server SQL CE is an embedded database – which makes it ideal for development, testing, and light-usage scenarios. For high-volume sites and applications you’ll probably want
to migrate your database
to use SQL Server Express (which is free), SQL Server or SQL Azure. These servers enable much better scalability, more development features (including features like Stored Procedures – which aren’t supported with SQL CE), as well as more advanced data management capabilities. We’ll ship migration tools that enable you
to optionally take SQL CE databases and easily upgrade them
to use SQL Server Express, SQL Server, or SQL Azure. You will not need
to change your code when upgrading a SQL CE database
to SQL Server or SQL Azure. Our goal is
to enable you
to be able
to simply change the database connection string
in your
web.config file and have your application just work. New Tooling Support for SQL CE
in VS 2010 SP1 VS 2010 SP1 includes much improved tooling support for SQL CE, and adds support for using SQL CE within
ASP.
NET projects for the first time. With VS 2010 SP1 you can now: Create new SQL CE Databases Edit and Modify SQL CE Database Schema and Indexes Populate SQL CE Databases within Data Use the Entity Framework (EF) designer
to create model layers against SQL CE databases Use EF Code First
to define model layers
in code, then create a SQL CE database from them, and optionally edit the DB with VS Deploy SQL CE databases
to remote servers using
Web Deploy and optionally convert them
to full SQL Server databases You can take advantage of all of the above features from within both
ASP.
NET Web Forms and
ASP.
NET MVC based projects. Download You can enable SQL CE tooling support within VS 2010 by first installing VS 2010 SP1 (beta). Once SP1 is installed, you’ll also then need
to install the SQL CE Tools for Visual Studio download. This is a separate download that enables the SQL CE tooling support for VS 2010 SP1. Walkthrough of Two Scenarios
In this blog post I’m going
to walkthrough
how you can take advantage of SQL CE and VS 2010 SP1 using both an
ASP.
NET Web Forms and an
ASP.
NET MVC based application. Specifically, we’ll walkthrough:
How to create a SQL CE database using VS 2010 SP1, then use the EF4 visual designers
in Visual Studio
to construct a model layer from it, and then display and edit the data using an
ASP.
NET GridView control.
How to use an EF Code First approach
to define a model layer using POCO classes and then have EF Code-First “auto-create” a SQL CE database for us based on our model classes. We’ll then look at
how we can use the new VS 2010 SP1 support for SQL CE
to inspect the database that was created, populate it with data, and later make schema changes
to it. We’ll do all this within the context of an
ASP.
NET MVC based application. You can follow the two walkthroughs below on your own machine by installing VS 2010 SP1 (beta) and then installing the SQL CE Tools for Visual Studio download (which is a separate download that enables SQL CE tooling support for VS 2010 SP1). Walkthrough 1: Create a SQL CE Database, Create EF Model Classes, Edit the Data with a GridView This first walkthrough will demonstrate
how to create and define a SQL CE database within an
ASP.
NET Web Form application. We’ll then build an EF model layer for it and use that model layer
to enable data editing scenarios with an <asp:GridView> control. Step 1: Create a new
ASP.
NET Web Forms Project We’ll begin by using the File->New Project menu command within Visual Studio
to create a new
ASP.
NET Web Forms project. We’ll use the “ASP.
NET Web Application” project template option so that it has a default UI skin implemented: Step 2: Create a SQL CE Database Right click on the “App_Data” folder within the created project and choose the “Add->New Item” menu command: This will bring up the “Add Item” dialog box. Select the “SQL Server Compact 4.0 Local Database” item (new
in VS 2010 SP1) and name the database file
to create “Store.sdf”: Note that SQL CE database files have a .sdf filename extension. Place them within the /App_Data folder of your
ASP.
NET application
to enable easy deployment. When we clicked the “Add” button above a Store.sdf file was added
to our project: Step 3: Adding a “Products” Table Double-clicking the “Store.sdf” database file will open it up within the Server Explorer tab. Since it is a new database there are no tables within it: Right click on the “Tables” icon and choose the “Create Table” menu command
to create a new database table. We’ll name the new table “Products” and add 4 columns
to it. We’ll mark the first column as a primary key (and make it an identify column so that its value will automatically increment with each new row): When we click “ok” our new Products table will be created
in the SQL CE database. Step 4: Populate with Data Once our Products table is created it will show up within the Server Explorer. We can right-click it and choose the “Show Table Data” menu command
to edit its data: Let’s add a few sample rows of data
to it: Step 5: Create an EF Model Layer We have a SQL CE database with some data
in it – let’s now create an EF Model Layer that will provide a way for us
to easily query and update data within it. Let’s right-click on our project and choose the “Add->New Item” menu command. This will bring up the “Add New Item” dialog – select the “ADO.
NET Entity Data Model” item within it and name it “Store.edmx” This will add a new Store.edmx item
to our solution explorer and launch a wizard that allows us
to quickly create an EF model: Select the “Generate From Database” option above and click next. Choose
to use the Store.sdf SQL CE database we just created and then click next again. The wizard will then ask you what database objects you want
to import into your model. Let’s choose
to import the “Products” table we created earlier: When we click the “Finish” button Visual Studio will open up the EF designer. It will have a Product entity already on it that maps
to the “Products” table within our SQL CE database: The VS 2010 SP1 EF designer works exactly the same with SQL CE as it does already with SQL Server and SQL Express. The Product entity above will be persisted as a class (called “Product”) that we can programmatically work against within our
ASP.
NET application. Step 6: Compile the Project Before using your model layer you’ll need
to build your project. Do a Ctrl+Shift+B
to compile the project, or use the Build->Build Solution menu command. Step 7: Create a Page that Uses our EF Model Layer Let’s now create a simple
ASP.
NET Web Form that contains a GridView control that we can use
to display and edit the our Products data (via the EF Model Layer we just created). Right-click on the project and choose the Add->New Item command. Select the “Web Form from Master Page” item template, and name the page you create “Products.aspx”. Base the master page on the “Site.Master” template that is
in the root of the project. Add an <h2>Products</h2> heading the new Page, and add an <asp:gridview> control within it: Then click the “Design” tab
to switch into design-view. Select the GridView control, and then click the top-right corner
to display the GridView’s “Smart Tasks” UI: Choose the “New data source…” drop down option above. This will bring up the below dialog which allows you
to pick your Data Source type: Select the “Entity” data source option – which will allow us
to easily connect our GridView
to the EF model layer we created earlier. This will bring up another dialog that allows us
to pick our model layer: Select the “StoreEntities” option
in the dropdown – which is the EF model layer we created earlier. Then click next – which will allow us
to pick which entity within it we want
to bind to: Select the “Products” entity
in the above dialog – which indicates that we want
to bind against the “Product” entity class we defined earlier. Then click the “Enable automatic updates” checkbox
to ensure that we can both query and update Products. When you click “Finish” VS will wire-up an <asp:EntityDataSource>
to your <asp:GridView> control: The last two steps we’ll do will be
to click the “Enable Editing” checkbox on the Grid (which will cause the Grid
to display an “Edit” link on each row) and (optionally) use the Auto Format dialog
to pick a UI template for the Grid. Step 8: Run the Application Let’s now run our application and browse
to the /Products.aspx page that contains our GridView. When we do so we’ll see a Grid UI of the Products within our SQL CE database. Clicking the “Edit” link for any of the rows will allow us
to edit their values: When we click “Update” the GridView will post back the values, persist them through our EF Model Layer, and ultimately save them within our SQL CE database. Learn More about using EF with
ASP.
NET Web Forms Read this tutorial series on the http://asp.
net site to learn more about
how to use EF with
ASP.
NET Web Forms. The tutorial series uses SQL Express as the database – but the nice thing is that all of the same steps/concepts can also now also be done with SQL CE. Walkthrough 2: Using EF Code-First with SQL CE and
ASP.
NET MVC 3 We used a database-first approach with the sample above – where we first created the database, and then used the EF designer
to create model classes from the database.
In addition
to supporting a designer-based development workflow, EF also enables a more code-centric option which we call “code first development”. Code-First Development enables a pretty sweet development workflow. It enables you to: Define your model objects by simply writing “plain old classes” with no base classes or visual designer 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 Optionally auto-create a database based on the model classes you define – allowing you
to start from code first I’ve done several blog posts about EF Code First
in the past – I really think it is great. The good news is that it also works very well with SQL CE. The combination of SQL CE, EF Code First, and the new VS tooling support for SQL CE, enables a pretty nice workflow. Below is a simple example of
how you can use them
to build a simple
ASP.
NET MVC 3 application. Step 1: Create a new
ASP.
NET MVC 3 Project We’ll begin by using the File->New Project menu command within Visual Studio
to create a new
ASP.
NET MVC 3 project. We’ll use the “Internet Project” template so that it has a default UI skin implemented: Step 2: Use NuGet
to Install EFCodeFirst Next we’ll use the NuGet package manager (automatically installed by
ASP.
NET MVC 3)
to add the EFCodeFirst library
to our project. We’ll use the Package Manager command shell
to do this. Bring up the package manager console within Visual Studio by selecting the View->Other Windows->Package Manager Console menu command. Then type: install-package EFCodeFirst within the package manager console
to download the EFCodeFirst library and have it be added
to our project: When we enter the above command, the EFCodeFirst library will be downloaded and added
to our application: Step 3: Build Some Model Classes Using a “code first” based development workflow, we will create our model classes first (even before we have a database). We create these model classes by writing code. For this sample, we will right click on the “Models” folder of our project and add the below three classes
to our project: The “Dinner” and “RSVP” model classes above are “plain old CLR objects” (aka POCO). They do not need
to derive from any base classes or implement any interfaces, and the properties they expose are standard .
NET data-types. No data persistence attributes or data code has been added
to them. The “NerdDinners” class derives from the DbContext class (which is supplied by EFCodeFirst) and handles the retrieval/persistence of our Dinner and RSVP instances from a database. Step 4: Listing Dinners We’ve written all of the code necessary
to implement our model layer for this simple project. Let’s now expose and implement the URL: /Dinners/Upcoming within our project. We’ll use it
to list upcoming dinners that happen
in the future. We’ll do this by right-clicking on our “Controllers” folder and select the “Add->Controller” menu command. We’ll name the Controller we want
to create “DinnersController”. We’ll then implement an “Upcoming” action method within it that lists upcoming dinners using our model layer above. We will use a LINQ query
to retrieve the data and pass it
to a View
to render with the code below: We’ll then right-click within our Upcoming method and choose the “Add-View” menu command
to create an “Upcoming” view template that displays our dinners. We’ll use the “empty” template option within the “Add View” dialog and write the below view template using Razor: Step 4: Configure our Project
to use a SQL CE Database We have finished writing all of our code – our last step will be
to configure a database connection-string
to use. We will point our NerdDinners model class
to a SQL CE database by adding the below <connectionString>
to the
web.config file at the top of our project: EF Code First uses a default convention where context classes will look for a connection-string that matches the DbContext class name. Because we created a “NerdDinners” class earlier, we’ve also named our connectionstring “NerdDinners”. Above we are configuring our connection-string
to use SQL CE as the database, and telling it that our SQL CE database file will live within the \App_Data directory of our
ASP.
NET project. Step 5: Running our Application Now that we’ve built our application, let’s run it! We’ll browse
to the /Dinners/Upcoming URL – doing so will display an empty list of upcoming dinners: You might ask – but where did it query
to get the dinners from? We didn’t explicitly create a database?!? One of the cool features that EF Code-First supports is the ability
to automatically create a database (based on the schema of our model classes) when the database we point it at doesn’t exist. Above we configured EF Code-First
to point at a SQL CE database
in the \App_Data\ directory of our project. When we ran our application, EF Code-First saw that the SQL CE database didn’t exist and automatically created it for us. Step 6: Using VS 2010 SP1
to Explore our newly created SQL CE Database Click the “Show all Files” icon within the Solution Explorer and you’ll see the “NerdDinners.sdf” SQL CE database file that was automatically created for us by EF code-first within the \App_Data\ folder: We can optionally right-click on the file and “Include
in Project"
to add it
to our solution: We can also double-click the file (regardless of whether it is added
to the project) and VS 2010 SP1 will open it as a database we can edit within the “Server Explorer” tab of the IDE. Below is the view we
get when we double-click our NerdDinners.sdf SQL CE file. We can drill
in to see the schema of the Dinners and RSVPs tables
in the tree explorer. Notice
how two tables - Dinners and RSVPs – were automatically created for us within our SQL CE database. This was done by EF Code First when we accessed the NerdDinners class by running our application above: We can right-click on a Table and use the “Show Table Data” command
to enter some upcoming dinners
in our database: We’ll use the built-in editor that VS 2010 SP1 supports
to populate our table data below: And now when we hit “refresh” on the /Dinners/Upcoming URL within our browser we’ll see some upcoming dinners show up: Step 7: Changing our Model and Database Schema Let’s now modify the schema of our model layer and database, and walkthrough one way that the new VS 2010 SP1 Tooling support for SQL CE can make this easier. With EF Code-First you typically start making database changes by modifying the model classes. For example, let’s add an additional string property called “UrlLink”
to our “Dinner” class. We’ll use this
to point
to a link for more information about the event: Now when we re-run our project, and visit the /Dinners/Upcoming URL we’ll see an error thrown: We are seeing this error because EF Code-First automatically created our database, and by default when it does this it adds a table that helps tracks whether the schema of our database is
in sync with our model classes. EF Code-First helpfully throws an error when they become out of sync – making it easier
to track down issues at development time that you might otherwise only find (via obscure errors) at runtime. Note that if you do not want this feature you can turn it off by changing the default conventions of your DbContext class (in this case our NerdDinners class)
to not track the schema version. Our model classes and database schema are out of sync
in the above example – so
how do we fix this? There are two approaches you can use today: Delete the database and have EF Code First automatically re-create the database based on the new model class schema (losing the data within the existing DB) Modify the schema of the existing database
to make it
in sync with the model classes (keeping/migrating the data within the existing DB) There are a couple of ways you can do the second approach above. Below I’m going
to show
how you can take advantage of the new VS 2010 SP1 Tooling support for SQL CE
to use a database schema tool
to modify our database structure. We are also going
to be supporting a “migrations” feature with EF
in the future that will allow you
to automate/script database schema migrations programmatically. Step 8: Modify our SQL CE Database Schema using VS 2010 SP1 The new SQL CE Tooling support within VS 2010 SP1 makes it easy
to modify the schema of our existing SQL CE database.
To do this we’ll right-click on our “Dinners” table and choose the “Edit Table Schema” command: This will bring up the below “Edit Table” dialog. We can rename, change or delete any of the existing columns
in our table, or click at the bottom of the column listing and type
to add a new column. Below I’ve added a new “UrlLink” column of type “nvarchar” (since our property is a string): When we click ok our database will be updated
to have the new column and our schema will now match our model classes. Because we are manually modifying our database schema, there is one additional step we need
to take
to let EF Code-First know that the database schema is
in sync with our model classes. As i mentioned earlier, when a database is automatically created by EF Code-First it adds a “EdmMetadata” table
to the database
to track schema versions (and hash our model classes against them
to detect mismatches between our model classes and the database schema): Since we are manually updating and maintaining our database schema, we don’t need this table – and can just delete it: This will leave us with just the two tables that correspond
to our model classes: And now when we re-run our /Dinners/Upcoming URL it will display the dinners correctly: One last touch we could do would be
to update our view
to check for the new UrlLink property and render a <a> link
to it if an event has one: And now when we refresh our /Dinners/Upcoming we will see hyperlinks for the events that have a UrlLink stored
in the database: Summary SQL CE provides a free, embedded, database engine that you can use
to easily enable database storage. With SQL CE 4 you can now take advantage of it within
ASP.
NET projects and applications (both
Web Forms and MVC). VS 2010 SP1 provides tooling support that enables you
to easily create, edit and modify SQL CE databases – as well as use the standard EF designer against them. This allows you
to re-use your existing skills and data knowledge while taking advantage of an embedded database option. This is useful both for small applications (where you don’t need the scalability of a full SQL Server), as well as for development and testing scenarios – where you want
to be able
to rapidly develop/test your application without having a full database instance. SQL CE makes it easy
to later migrate your data
to a full SQL Server or SQL Azure instance if you want
to – without having
to change any code
in your application. All we would need
to change
in the above two scenarios is the <connectionString> value within the
web.config file
in order
to have our code run against a full SQL Server. This provides the flexibility
to scale up your application starting from a small embedded database solution as needed. Hope this helps, Scott P.S.
In addition
to blogging, I am also now using Twitter for quick updates and
to share links. Follow me at: twitter.com/scottgu
