How to Get Started With ADO.NET Entity Framework 4 and Visual Studio 2010 (Beta 2)

dacrowlah — Sun, 31 Jan 2010 23:03:00 GMT

Introduction

The upcoming release of the .NET Framework version 4.0 and the simultaneous release of Visual Studio 2010 comes with a host of upgrades to the Entity Framework. The Entity Framework is Microsofts officially supported Object Relational Mapping (ORM) tool used to connect .NET based applications and websites to the databases that run them. It provides strongly typed access to the underlying tables and comes with full integration with LINQ. The goal of this post is to help you get your feet wet with a step by step tutorial on the Entity Framework 4 and integrating it with a simple ASP.NET based web application.

What you will need to get started to follow along with this tutorial on your own and to use the associated code download:

Download and install the Visual Studio 2010 Ultimate Beta 2 release, and do a full install.
SQL 2008 Express installed locally on your development workstation
The optional code download of this project

Getting Started

First, open up Visual Studio and click on File -> New -> Project, select "ASP.NET Web Application" and name it EntityFramework4Test, and click OK. This will create a very basic web application with all of the references that we need already set. The project will open to the source view of the Default.aspx page, with some stub code that Microsoft puts there by default. Go ahead and clear out everything inside of the <asp:Content ID="BodyContent"....> tag. We will be back here in a moment.

Next, right click on the EntityFramework4Test project in the solution explorer (the line directly below "Solution 'EntityFramework4Test' (1 Project) at the top), and click Add -> New Item. From this dialog window click on Data in the left pane; this will filter down to a shorter list of items, from this list select ADO.NET Entity Data Model, name it Demo.edmx and click Add. The next window will ask "What should the model contain?" and give you the choice between "Generate from database" and "Empty Model". Select Empty Model and click Next. The next screen will ask which data connection to use. We'll name our database here Demo, so if you have a Demo database that you are already using, just substitute what ever name you like for Demo. Set up a new connection to this database and if it needs created, let the process create it. When it is done, it will bring up the Demo.edmx designer window with a blank slate.

Creating the Entities

Right click on the blank designer and click Add -> Entity... leave all of the fields in their default state, except for the Entity Name field, let's fill that out with "Person". When we do this, notice lower down on the dialog window, the "Entity Set" field.. it automatically types with you and pluralizes the word for you. In this case, its "People" - this is the property by which we will later refer to a Collection of Person objects. Click OK, and the entity will be added to the designer. Repeat this process and add an entity named Group.

Since these entities will refer directly to database tables, we need to construct them in a manner consistent with how we design tables. The entities by default have a primary key defined on them called "Id"; however these fields are not automatically marked as identity. Right click on each of the Id fields, select Properties and in the Properties window, look for the field labeled "StoreGeneratedPattern" - this will indicate that the Store (data repository, i.e. database) will generate this value and that we do not need to be concerned with setting this value.

To add columns to the data entities, right click on them (note: right clicking on different areas of the Entity will give you different context menus, for this part, right click on the top of the Entity and Add should be the first context menu item. When you find the Add menu item, select Add -> Scalar Property. It will add the field to the entity and allow you to change the name; after you name it, you can right click on the property field and select "Properties" and change the Type to what ever is appropriate for the field we're adding.

Add the following fields to Person:

FirstName - give it a type of String
LastName - give it a type of String
EmailAddress - give it a type of String
DateCreated - give it a type of DateTime

Add the following fields to Group:

Name - give it a type of String
DateCreated - give it a type of DateTime
Description - give it a type of String

Next, right click on the canvas again, and select Add -> Association; since we only have two entities right now, the the Entity: drop down will already be populated with each of the entities. Make sure that the Multiplicity: drop downs both have * (Many) selected. This will allow this to be a Many to Many association. We now have the basic data model setup for us to use, and we just need a database to back it all up.

Right click on the canvas again, and select Generate Database from Model and click Finish; this will bring up a T-SQL Editor window with the code necessary to create the schema. The only change we should make alter the behavior of the foreign keys on the PersonGroup table. The last line of the last ALTER TABLE statement is the one we want. Change the ON DELETE NO ACTION ON UPDATE NO ACTION to ON DELETE CASCADE ON UPDATE CASCADE.

This will automatically clear the records from the PersonGroup table when we delete rows from either Person or Group and prevent errors from being thrown or records being orphaned. Hit CTRL+SHIFT+E to execute the SQL, it may prompt you to connect to the database server, if so go ahead and do so. Provided it returns a message that the Command(s) completed successfully, we are now ready to use our Demo database.

Note: If you are running the downloaded project, you will need complete this step yourself - my project assumes that you are using SQL Server Express 2008, and not a file based SQL Server Database.

Accessing the Data from ASP.NET

Now that our entities are set up and the database and tables are created, let's open add a new Web Content Form to our web project. Call it AddPeopleAndGroup.aspx and click OK. Inside the Page_Load method, past the following code (or reference the download project):

//DemoEntities is the Type created that

//is the context to the database.

using (var context = new DemoEntities())

{

//let's create two people that we can add to a group

Person me = new Person()

{

FirstName = "Ryan",

LastName = "Crowley",

EmailAddress = "dontspamme@gmail.com",

DateCreated = DateTime.Now

};

Person you = new Person()

{

FirstName = "Your",

LastName = "Name",

EmailAddress = "dontspamyou@gmail.com",

DateCreated = DateTime.Now

};

Group ourGroup = new Group()

{

Name = "Our Group!",

Description = "Our Group Description!",

DateCreated= DateTime.Now

};

//Add the people to the group

ourGroup.People.Add(me);

ourGroup.People.Add(you);

//Now add the newly created Group to our table of Groups

context.Groups.AddObject(ourGroup);

// this is the method call that will

// persist the entire set of objects to the database

context.SaveChanges();

}

Running this code won't output anything to the screen of course, but it will illustrate the simplicity of adding records to the database. If we now go and select from all of our tables, we can see the data that we just saved. Now, on to reading that data back out and displaying it!

Reading The Data

Let's go into the Default.aspx file and add a GridView with the ID of "gvGroups" and one with the ID of "gvPeople", and leave everything else default - this will let the GridViews auto generate the column names.

Now let's open up the Default.aspx.cs and paste the following code into it (again, or reference the download):

using (var context = new DemoEntities())

{

gvGroups.DataSource = context.Groups;

gvGroups.DataBind();

gvPeople.DataSource = context.People;

gvPeople.DataBind();

}

Voila! Running this will display two grids: one with the group that we just created and one with the people we just created.

That's all for this tutorial. Soon there will be more examples posted as well as a series involving the construction of a more complex, fully functional application.