Entity Framework 4 Basics Part 1

ADO .NET Entity Framework

Entity Framework is an Object/Relational Mapping (ORM) tool created by the ADO .NET team at Microsoft®. ORM tools, in general, map database tables and relationships to auto-generated objects. There are many ORM tools out there, many of which are quite good. Here are just a few of the ORM tools I have used in the past: NHibernate, LLBLGen, Habenero, and LINQ to SQL. In addition to existing frameworks, you can also go the “create your own” route using code generation (T4, CodeSmith, MyGeneration, etc). This offers the most control over data access, but takes longer to get setup.

Entity Framework is great because it’s built into Visual Studio 2010 by default, it’s easy to use and customize, and integrates nicely with the rest of the .NET Framework, making it my favorite ORM to date.

In this post I will cover the basics of Entity Framework, using a simple single layer implementation, and access the generated Entity Framework code directly from our presentation layer. Obviously this isn’t a best practice, so in a future post I will show how to setup Entity Framework in multi-layer architecture. If you’re completely new to Entity Framework, take a look at this videos series from MSDN that walks you through adding a model to your solution and the basics of using the tools.

CRUD Operations

If you’re not familiar with the CRUD acronym, it stands for Create, Read, Update, Delete. In my opinion, handling CRUD is where an ORM tool really makes sense. Single table CRUD operations are, for the most part, technically trivial operations. However coding them all “by hand” is time consuming and error prone. If you’re not using an ORM tool or code generation tool of some sort to automate the creation of this code, you should definitely consider it.

Data Model

Very simple – only two tables, Group and Employee. Each employee belongs to one group.

Create Example

To show how to use Entity Framework to insert data, we will create a new group. Here is our user interface and the code to add a group.

private void CreateGroup(string groupName)
{
	using (TestDatabaseEntities ctx = new TestDatabaseEntities())
	{
		ctx.Groups.AddObject(new Group()
		{
			GroupName = groupName
		});

		ctx.SaveChanges();
	}
}

Read Example

This example searches for employees that are in a certain group, returns then ordered by last name descending, and binds them to a results grid.

private void GetEmployees(string groupName)
{
	List<Employee> employees = null;

	using (TestDatabaseEntities ctx = new TestDatabaseEntities())
	{
		employees = ctx.Employees
			.Include("Group")
			.Where(e => e.Group.GroupName == groupName)
			.OrderByDescending(e => e.LastName)
			.ToList();
	}

	gvEmployees.DataSource = employees;
	gvEmployees.DataBind();
}

Update Example

This example searches for a group by ID, loads that group name into a textbox, and allows the user to update it’s value.

private Group GetGroup(int groupID)
{
	using (TestDatabaseEntities ctx = new TestDatabaseEntities())
	{
		return ctx.Groups
			.Where(g =< g.GroupID == groupID)
			.FirstOrDefault();
	}
}

private void UpdateGroup(int groupID, string groupName)
{
	Group group = GetGroup(groupID);

	if (group != null)
	{
		group.GroupName = groupName;

		using (TestDatabaseEntities ctx = new TestDatabaseEntities())
		{
			ctx.Groups.Attach(group);

			ObjectStateEntry groupEntry = ctx.ObjectStateManager.GetObjectStateEntry(group);
			groupEntry.ChangeState(EntityState.Modified);

			ctx.SaveChanges();
		}
	}
}

A couple things of note in this example. First, in the GetGroup method, I’m using the FirstOrDefault method in the System.Linq namespace. The reason for this is that since I’m matching on the primary key, I know that my query can return at most one record. However it may not return a record, which is why I choose it over the First method. Since I’m querying the primary key, perhaps a better choice is the Single method or SingleOrDefault method, as these methods expect only one result, and throw an exception if there is more than one element in the sequence.

Second, because the get and update methods are separated, and therefore using separate instances of the ObjectContext, I have to attach the Group object returned by my GetGroup method to the in scope ObjectContext of my update method. Then I have to tell the ObjectContext that the entity has been modified so that when SaveChanges is called it will update that record. It’s more efficient to have both the get and update operations under the same context, but because this isn’t always possible I included the example here.

Delete Example

For the delete example, I will delete a group by name. Deleting by name isn’t a great idea in a real application, but I wanted to mix it up a little.

private void DeleteGroup(string groupName)
{
	using (TestDatabaseEntities ctx = new TestDatabaseEntities())
	{
		Group group = ctx.Groups
			.Where(g => g.GroupName == groupName)
			.FirstOrDefault(); 

		if (group != null)
		{
			ctx.Groups.DeleteObject(group);

			ctx.SaveChanges();
		}
	}
}

This time I get the group and mark it as deleted in the same ObjectContext, so there is no need to attach and change state. You do, however, need to remember to call SaveChanges on your context.

Download

Entity Framework Basics 1

This work is licensed under a Creative Commons Attribution 3.0 Unported License.