Fr

ee

Sa
m

pl

In this package, you will find:

The author biography

A preview chapter from the book, Chapter 1 Introduction to
Entity Framework
A synopsis of the books content
More information on Mastering Entity Framework

About the Author

Rahul Rajat Singh has over 9 years of experience in developing software applications
and websites. After completing his bachelor's degree in computer engineering in 2005, he
started working with Tata Consultancy Services (TCS), where he worked on developing
audio/video playback engines using C++ for a multimedia company. During this period,
he also developed a few small applications using C# and that was the beginning of his
love for C#.
After working with TCS for more than 4 years, he took up an independent software
assignment and worked on developing a Windows Forms application using C#. During
this period, he also started lecturing on programming languages for engineering students.
This teaching assignment encouraged him to share his knowledge through more channels,
and he started sharing articles on www.codeproject.com.
He started working on web applications when he joined MPOnline Limited.
MPOnline Limited, being the best e-governance portal of the country, gave him
immense opportunities to learn and implement a lot of web technologies, such as
ASP.NET, ADO.NET, JavaScript, SQL Server, Web services, and WCF services.
Currently, he is working with a Danish company called Headfitted Solutions as
a technical architect, where he develops applications using ASP.NET MVC, Entity
Framework, scalable REST-based services using WCF and ASP.NET Web API, and
Single-Page Applications (SPAs) using Backbone.js. He is currently learning more
about software architecture and enterprise architecture.

Rahul loves software development, and his interests involve system programming,
website development, and learning/teaching subjects related to computer science /
information systems. He was also awarded CodeProject MVP in 2013 and DZone
MVB in 2014. He blogs regularly about technology on his blog
(www.rahulrajatsingh.com).
I would like to thank my wife and daughter for their love and support and
being patient with the long working hours that enabled me to write this book.
I would like to thank my parents for everything they have done for me.
Everything I am today is because of them. Finally, I would like to thank a
couple of my mentors Mr. Himanshu Agnihotri and Mr. Amalraj P for
supporting me during my struggle period and showing me the right path.

Mastering Entity Framework

Software developers using .NET technologies have been using ADO.NET for data access
for more than a decade. It was with the release of .NET Framework 3.5 that Microsoft
provided one more data access technologyEntity Framework. Entity Framework is an
Object Relational Mapper (ORM) that sits on top of ADO.NET. Entity Framework lets
the developer write the data access code in terms of models rather than SQL queries,
which makes creating the data access layer much simpler and easier.
This book is for the .NET developers who develop data-driven applications using
ADO.NET or other data access technologies. This book will give them everything
that is required to effectively develop and manage data-driven applications using
Entity Framework. We will learn the various approaches that Entity Framework
provides us and which approach should be used for which scenario. We will learn
how to perform domain modeling, validations, transaction and concurrency handling
using Entity Framework.
We will also take a look at the various ways of querying the data using Entity
Framework. We will see how we can reuse database procedures using Entity
Framework. We will also take a look at passing dynamic queries from the
application using Entity Framework. This book will help developers build
all the skills required to effectively develop and manage data-driven
applications using Entity Framework.

What This Book Covers

Chapter 1, Introduction to Entity Framework, introduces the user to Entity Framework.
We will show how a data-centric application can benefit from the Database First
approach and a domain-centric application can benefit from a Model First or Code
First approach.
Chapter 2, Entity Framework DB First Managing Entity Relationships, discusses
how relationships can be managed using Entity Framework (one-to-one, one-to-many,
and many-to-many).
Chapter 3, Entity Framework DB First Performing Model Validations, discusses
how model validations can be performed using the Entity Framework provided
partial methods.
Chapter 4, Entity Framework DB First Inheritance Relationships between Entities,
discusses the Table per Type, Table per Hierarchy, and Table per Concrete Class
inheritance relationships in Entity Framework.

Chapter 5, Entity Framework DB First Using Views, Stored Procedures, and

Functions, discusses how we can use Entity Framework with stored procedures
and functions.
Chapter 6, Entity Framework Code First Domain Modeling and Managing Entity
Relationships, discusses how we can map the domain entities to the database tables.
We will learn how to manage the relationships between models by using the Code
First conventions and configurations.
Chapter 7, Entity Framework Code First Managing Database Creation and Seeding
Data, discusses how we can manage the database creation process and insert some
dummy data into the database.
Chapter 8, Querying the Entity Data Model LINQ to Entities, discusses how we
can query the object model using LINQ to Entities.
Chapter 9, Querying the Object Model Entity SQL, discusses how we can query
the object model using Entity SQL
Chapter 10, Managing Concurrency Using Entity Framework, covers various
concurrency management techniques using Entity Framework.
Chapter 11, Managing Transactions Using Entity Framework, discusses how
to manage transactions using Entity Framework.
Chapter 12, Implementing a Small Blogging Platform Using Entity Framework,
introduces a complete sample application using the Entity Framework Code First
approach to demonstrate all the concepts in action.

Introduction to
Entity Framework
Entity Framework is an Object Relational Mapper (ORM) from Microsoft that
lets the application's developers work with relational data as business models. It
eliminates the need for most of the plumbing code that developers write (while
using ADO.NET) for data access. Entity Framework provides a comprehensive,
model-based system that makes the creation of a data access layer very easy for
the developers by freeing them from writing similar data access code for all the
domain models. The initial release of Entity Framework was Entity Framework 3.5.
It was released with .NET Framework 3.5 SP1 and Visual Studio 2008 SP1. Entity
Framework has evolved a lot since then, and the current version is 6.0.
Entity Framework eases the task of creating a data access layer by enabling the access
of data, by representing the data as a conceptual model, that is, a set of entities and
relationships. The application can perform the basic CRUD (create, read, update, and
delete) operations and easily manage one-to-one, one-to-many, and many-to-many
relationships between the entities.
Here are a few benefits of using Entity Framework:

The development time is reduced since the developers don't have to write all
the ADO.NET plumbing code needed for data access

We can have all the data access logic written in a higher-level language such
as C# rather than writing SQL queries and stored procedures

Since the database tables cannot have advanced relationships (inheritance) as

the domain entities can, the business model, that is, the conceptual model can
be used to suit the application domain using relationships among the entities.

Introduction to Entity Framework

The underlying data store can be replaced relatively easily if we use an

ORM since all the data access logic is present in our application instead of the
data layer. If an ORM is not being used, it would be comparatively difficult
to do so.

Let's try to visualize the Entity Framework architecture:

The Entity Framework architecture

From the preceding diagram, we can see that Entity Framework is written on top of
the ADO.NET framework, and underneath, it is still using the ADO.NET methods
and classes to perform the data operations.

Entity Framework modeling and

persistence
Entity Framework relies on the conceptual data model for all its working. Let's try to
understand what the Entity Data Model (EDM) is and how Entity Framework uses
it to manage the database operations.

[8]

Chapter 1

Understanding the Entity Data Model

The conceptual data model is the heart of Entity Framework. To use Entity
Framework, we have to create the conceptual data model, that is, the EDM. The EDM
defines our conceptual model classes, the relationships between those classes, and
the mapping of those models to the database schema.
Once our EDM is created, we can perform all the CRUD operations (create, retrieve,
update, and delete) on our conceptual model, and Entity Framework will translate
all these object queries to database queries (SQL). Once these queries are executed,
the results will again be converted to conceptual model object instances by Entity
Framework. Entity Framework will use the mapping information stored in the EDM
to perform this translation of object queries to SQL queries, and the relational data to
conceptual models.
Once our EDM is ready, we can perform the CRUD operations using the model objects.
To be able to perform the CRUD operations, we have to use the ObjectContext class.
Let's try to understand what the ObjectContext class is and how it can be used to
perform the CRUD operations.

Understanding the ObjectContext class

Once I have my EDM created, I will have all the entities that I can use in my
application. However, I still need a central arbitrator that will let me perform
various operations on these entities. This arbitrator in Entity Framework is the
ObjectContext class.
The ObjectContext class is the main object in Entity Framework. It is the class that
is responsible for:

Managing database connection

Providing support to perform CRUD operations

Keeping track of changes in the models so that the models can be updated in
the database

The ObjectContext class can be thought of as an orchestrator that will manage

all the entities in the EDM, and lets us perform all of the database operations for
these entities.

[9]

Introduction to Entity Framework

There is another class, DbContext, that is very similar to the

ObjectContext class. In fact, the DbContext class is just
a wrapper on top of the ObjectContext class. It is a rather
newer API, and it provides a better API to manage database
connections and perform CRUD operations.
Since DbContext is a better API, we will be using DbContext
to perform all the database operations.

The ObjectContext class has a SaveChanges method that we have to call when we
want to save the new or changed objects to the database.

Development styles and different Entity

Framework approaches
Before we start looking at the various options to create the EDM, let's talk about the
development styles followed by the developers. Some organizations have separate
teams working on the application and the database. In such cases, the database
design is done first and then the application development starts. Another reason for
doing the database design first is when the application being developed is a data
centric application itself.
Instead, it might be possible that the application demands the creation of the
conceptual domain models first. Then, based on these conceptual domain models,
the database tables will be created, and the application will implement the business
logic in terms of these conceptual business models.
Another possibility is that we are creating an application that is highly domain-centric,
and the application contains the domain models implemented as classes. The database
is needed only to persist these models with all the relations.
There are a range of different scenarios you might find yourself indifferent
approaches become appropriate according to the demands of your situation.
Entity Framework provides support for all these development styles and scenarios.
We know that Entity Framework operates on the EDM, and lets us create this EDM
in three ways in order to cater to the different development styles:

Database First: This is the approach that will be used with an existing
database schema. In this approach, the EDM will be created from the database
schema. This approach is best suited for applications that use an already
existing database.
[ 10 ]

Chapter 1

Code First: This is the approach where all the domain models are written
in the form of classes. These classes will constitute our EDM. The database
schema will be created from these models. This approach is best suited
for applications that are highly domain-centric and will have the domain
model classes created first. The database here is needed only as a persistence
mechanism for these domain models.

Model First: This approach is very similar to the Code First approach, but in
this case, we use a visual EDM designer to design our models. The database
schema and the classes will be generated by this conceptual model. The
model will give us the SQL statements needed to create the database, and
we can use it to create our database and connect up with our application.
For all practical purposes, it's the same as the Code First approach, but in
this approach, we have the visual EDM designer available.

Comparing the development styles

Before we start looking at these development styles in detail, let's try to do
a comparative analysis of these styles. It will help us in understanding these
styles in detail.

The Database First approach

In a Database First approach, the main benefit that the developers have is that if the
database is created, they will spend very little time writing the data access layer.
The EDM can be created from the database and then we can change it as per our
application needs; our data access layer is ready to use. Here are a few scenarios
where the Database First approach is very useful:

When we are working with a legacy database.

When we are working in a scenario where the database design is being done
by another team of DBAs, and once the database is ready, the application
development starts.

When we are working on a data centric application, that is, the application
domain model is the database itself, and it is being changed frequently to
cater to new requirements. For instance, when the tables are being updated
regularly and new columns are being added to it frequently then we can
simply use this approach, and the application code will not break. We simply
have to write the code to cater to the newly added columns.

[ 11 ]

Introduction to Entity Framework

The Model First approach

Similar to the Database First approach, in the Model First approach, we ultimately
end up with the EDM. Using this EDM, we can create our conceptual model and
the database. The only reason to choose the Model First approach is that we really
want to use the Visual Entity Designer. There is no other strong reason to choose this
approach over the other two.

The Code First approach

The Code First approach is usually helpful where all the business logic is
implemented in terms of classes, and the database is simply being used as a
persistence mechanism for these models. Here are a few reasons why one might
want to choose the Code First approach:

The database is simply a persistence mechanism for the models, that is, no
logic is in the database.

Full control over the code, that is, there is no auto-generated model and
context code.

The database will not be changed manually. The model classes will always
change and based on this, the database should change itself.

Entity Framework Database First

approach
This approach has been available since the first version of Entity Framework. In
this approach, we start with an already existing database and start creating our
EDM from the existing database. Let's try to see how this works using the Entity
Framework Database First approach with our ToDo sample. To use the Entity
Framework Database First approach, we have to add a new ADO.NET EDM to
our project:

[ 12 ]

Chapter 1

Add a new ADO.NET EDM

Let's start by defining a database for the ToDo application. Let's create a simple table
that will keep a track of all the ToDo items:

A table schema for the sample ToDo application

The application requirements state that it should be possible to perform the

following activities on the ToDos:

Read the list of ToDos

Create a ToDo item
Read a specific ToDo item
Update the status of a ToDo item
Delete a ToDo item
[ 13 ]

Introduction to Entity Framework

When we add the EDM, it asks us whether we want to create the conceptual model
from the existing database, or if we want to create an empty model. For the Database
First approach, we need to select an existing database. The following screenshot
shows the wizard step that asks you to select the database:

ADO.NET EDM wizard step 1generate from the database

[ 14 ]

Chapter 1

Once we choose to add the EDM, we need to specify the database that should be
used to create it. So, the next step in the wizard will ask you for the connection to the
database. Let's see what this wizard step looks like:

ADO.NET EDM wizard step 2select the database

[ 15 ]

Introduction to Entity Framework

Once the connection is successfully established, the wizard shows us all the tables,
views, procedures, and functions that we will want to access from our application.
Using this wizard, we can also choose to include the foreign key relations in our
conceptual model and singularization of the model name, in case the table name
is plural in our conceptual model:

ADO.NET EDM wizard step 3select the schema elements to be included in the EDM

[ 16 ]

Chapter 1

Once the conceptual model is created, the EDM will be created for use in our
application. The application will create a .EDMX file that contains all the information
about our conceptual entity model and its mapping to the database tables:

Visual Entity Designer showing the default model

[ 17 ]

Introduction to Entity Framework

We can modify the conceptual model and change the mapping using entity designer.
Let's try to change the property ToDo1 to ToDoItem in our conceptual model. Note
that only the class property has been changed, and not the column name:

Visual Entity Designer showing the customized model

If we open the EDMX file, we can find the following three sections:

Conceptual schema definition: This specifies how a strongly typed model for
our conceptual model will be created:
<edmx:ConceptualModels>
<Schema Namespace="ToDoDBModel" Alias="Self" annotation:UseStron
gSpatialTypes="false" xmlns:annotation="http://schemas.microsoft.
com/ado/2009/02/edm/annotation" xmlns="http://schemas.microsoft.
com/ado/2009/11/edm">
<EntityType Name="ToDo">
<Key>
[ 18 ]

Chapter 1
<PropertyRef Name="Id" />
</Key>
<Property Name="Id" Type="Int32" Nullable="false" />
<Property Name="TodoItem" Type="String" MaxLength="Max"
FixedLength="false" Unicode="true" Nullable="false" />
<Property Name="IsDone" Type="Boolean" Nullable="false" />
</EntityType>
<EntityContainer Name="ToDoDBEntities" annotation:LazyLoadingEna
bled="true">
<EntitySet Name="ToDos" EntityType="Self.ToDo" />
</EntityContainer>
</Schema>
</edmx:ConceptualModels>

Storage schema definition: This specifies how the storage model is created,
that is, how the values are stored in the database:
<edmx:StorageModels>
<Schema Namespace="ToDoDBModel.Store" Provider="System.
Data.SqlClient" ProviderManifestToken="2012" Alias="Self"
xmlns:store="http://schemas.microsoft.com/ado/2007/12/edm/
EntityStoreSchemaGenerator" xmlns="http://schemas.microsoft.com/
ado/2009/11/edm/ssdl">
<EntityType Name="ToDos">
<Key>
<PropertyRef Name="Id" />
</Key>
<Property Name="Id" Type="int" Nullable="false" />
<Property Name="Todo" Type="nvarchar(max)" Nullable="false" />
<Property Name="IsDone" Type="bit" Nullable="false" />
</EntityType>
<EntityContainer Name="ToDoDBModelStoreContainer">
<EntitySet Name="ToDos" EntityType="Self.ToDos" Schema="dbo"
store:Type="Tables" />
</EntityContainer>
</Schema>
</edmx:StorageModels>

Mapping: This specifies the mapping between the conceptual model and the
storage model:
<edmx:Mappings>
<Mapping Space="C-S" xmlns="http://schemas.microsoft.com/
ado/2009/11/mapping/cs">
<EntityContainerMapping StorageEntityContainer="ToDoDBModelStore
Container" CdmEntityContainer="ToDoDBEntities">
<EntitySetMapping Name="ToDos">
[ 19 ]

Introduction to Entity Framework

<EntityTypeMapping TypeName="ToDoDBModel.ToDo">
<MappingFragment StoreEntitySet="ToDos">
<ScalarProperty Name="Id" ColumnName="Id" />
<ScalarProperty Name="TodoItem" ColumnName="Todo" />
<ScalarProperty Name="IsDone" ColumnName="IsDone" />
</MappingFragment>
</EntityTypeMapping>
</EntitySetMapping>
</EntityContainerMapping>
</Mapping>
</edmx:Mappings>

We should always prefer to change these values from the

Visual Entity Designer. We can modify this XML manually to
change it as per our needs, but Visual Entity Designer allows
us to perform most of the modifications, and unless we need
to make a change that is not supported by entity designer,
we should try not to make them manually.

Once the EDM is created, we will get a class generated for each model object present
in our conceptual model. We will also get the DBContext class that will let's use these
strongly typed models:

Solution Explorer showing the generated DbContext and Model class

The generated DBContext class will look like this:

public partial class ToDoDBEntities : DbContext
{
public ToDoDBEntities()
: base("name=ToDoDBEntities")
{
}
public virtual DbSet<ToDo> ToDos { get; set; }
}
[ 20 ]

Chapter 1

The generated model class will look like this:

public partial class ToDo
{
public int Id { get; set; }
public string TodoItem { get; set; }
public bool IsDone { get; set; }
}

Now we are ready to write typed queries against the generated conceptual model, and
Entity Framework will execute our queries on the database, and return the results in
the form of these strongly typed models. Creating new data or updating the existing
data is also very easy, because Entity Framework automatically tracks the changes we
make in our models, and lets us save the changes to the database. This can simply be
done by calling the SaveChanges method on the DBContext class. One important thing
to note here is that the read operation can utilize Language-Integrated Query (LINQ)
to query the object data model, and Entity Framework will take care of converting it to
the appropriate SQL query and retrieve the results.
If our application is a data-centric application, and all we need is to be able to
perform CRUD operations using strongly typed objects, this is all that we are going
to need. However, one of the great benefits of Entity Framework is being able
to modify the conceptual models to better adapt to our domain needs, and then
use the mappings to map the domain model to the database tables. We can have
relationships between our domain models and still let them persist the data in a
given set of tables.
In the Database First approach, the Entity Model is able to
incrementally update the conceptual model if the database
schema is updated. We just need to right-click on the visual
designer and chose Update Model from Database.

In the later chapters, we will see how to manage multiple models, how we can define
relationships between the entities, introduce inheritance hierarchies, customize
entities, and much more. This will give you a good foundation to get started with
the Entity Framework Database First approach if you haven't used it before, and will
refresh your memory if you have.

[ 21 ]

Introduction to Entity Framework

Entity Framework Model First approach

The Model First approach is useful when we don't have a database to start with.
Using this approach, we can create our models directly in the Visual Entity Designer,
and then create the database schema based on our model. In this approach too, we
can create entities and their properties, define relationships and constraints between
the entities, and create inheritance relationships.
In this approach, we will first create the conceptual model, and based on this the
database and the strongly typed objects will be created. To start with the Model First
approach, we first need to add an ADO.NET EDM.
Let's try to add an ADO.NET EDM in our application:

Add a new ADO.NET EDM

[ 22 ]

Chapter 1

Since we are planning to start with an empty model, we have to select an empty
model in the wizard. The following screenshot shows the wizard step that asks you
to select the option. We have to select Empty model in this step:

ADO.NET EDM wizard step 1select the Model First approach

[ 23 ]

Introduction to Entity Framework

Once we choose the empty model, Entity Framework will show us the Visual Entity
Designer. Now we can add the entities and relations to the designer area from the
toolbar. The Entity Designer and the toolbar will look something like this:

An empty Visual Entity Designer after selecting the Model First approach

Let's try to add a new entity to our ToDo application and add properties to that
model. Let's add a few properties to our ToDo model:

Adding a new property from Visual Entity Designer

[ 24 ]

Chapter 1

Let's add the scalar properties needed for our ToDo model. Let's make the ID field a
primary key field, a string property for ToDoItem, and a Boolean property for IsDone:

Visual Studio's Property panes showing the properties of a conceptual model

The created entity will look something like this:

The final model created from the Visual Entity Designer

[ 25 ]

Introduction to Entity Framework

Once we have the conceptual model created for our application, we have to create
the database from this conceptual model. This can be done by right-clicking on the
entity and choosing Generate Database from Model:

Generating database scripts from the Visual Entity Designer

[ 26 ]

Chapter 1

This will prompt you to select the database connection. This wizard will not create
the actual database, but it will generate the DDL for us, and we will have to use that
DDL to create the database ourselves:

Wizard step to select the connection string to be used for a generated database script

[ 27 ]

Introduction to Entity Framework

After we select the database connection, the wizard will give us the SQL to create the
database on the specified connection:

Wizard step showing the create database script

[ 28 ]

Chapter 1

We can now copy this SQL and create the database. The Entity Framework has
already created connectionString to use this connection, and wired up the
DBContext class to perform the operations on this database. Let's take a look at the
generated DbContext class:
public partial class ToDoModelContainer : DbContext
{
public ToDoModelContainer()
: base("name=ToDoModelContainer")
{
}
public virtual DbSet<ToDo> ToDoes { get; set; }
}

The strongly typed objects will also be generated from the conceptual model. Let's
take a look at our generated ToDo class:
public partial class ToDo
{
public ToDo()
{
this.IsDone = false;
}
public int Id { get; set; }
public string ToDoItem { get; set; }
public bool IsDone { get; set; }
}

If we are using the Model First approach, one important thing to consider is that
the incremental changes in our model will not perform the incremental updates
to the database. Rather, it will give us the SQL to create the updated database from
the ground up.
If we want to perform incremental updates to the database,
we can use the Database Generation Power Pack from Microsoft
(https://visualstudiogallery.msdn.microsoft.com/
df3541c3-d833-4b65-b942-989e7ec74c87/). Using this,
we can perform incremental updates to the database.

[ 29 ]

Introduction to Entity Framework

Entity Framework Code First approach

Now, let's take a look at the Entity Framework Code First approach. In this approach,
we will start by creating the model classes ourselves. We will then implement our
business logic against these classes, and then if we need to persist these models, we
can use the Entity Framework Code First framework to save these models to the
database. Thus, the Entity Framework Code First approach enables us to write simple
C# classes, that is, Plain Old CLR Objects (POCOs) for our models, and then lets us
persist them in a data store by defining a DbContext class for our model classes.
So, if we want to implement our ToDo application using the Code First approach, we
will first have to create the ToDo model ourselves. Let's create a simple ToDo class
that will keep track of our ToDo items:
public class ToDo
{
public int Id { get; set; }
public string ToDoItem { get; set; }
public bool IsDone { get; set; }
}

Once we have the ToDo class ready, we need to start thinking about how the
database will be created from our classes. We need to tell Entity Framework how to
use our classes and generate the database accordingly. We want to tell the database
generation module about all the persistence information, such as table names, key
columns, and so on. We can do this in our model classes. So, if we try to put these
attributes in our model class, our resultant ToDo model will look like this:
[Table("ToDo")] // Table name
public class ToDo
{
[Key] // Primary key
public int Id { get; set; }
[Column("ToDoItem", TypeName="ntext")]
public string ToDoItem { get; set; }
[Column("IsDone", TypeName="bit")]
public bool IsDone { get; set; }
}

[ 30 ]

Chapter 1

In the preceding code, we updated our class with a table attribute passing in the
table name. This will tell the Entity Framework that a table should be created for this
class. Each property of the class can be updated with the Column attribute, and we
can specify the name of the column this property should be mapped to and the data
type. The Key attribute will be used to specify the property that should be used as a
primary key.
Entity Framework uses the DBContext class to save the models to the database. In
the Code First approach, we need to create the DBContext class ourselves too. Let's
see how we can implement our DBContext class:
public partial class ToDoDBContext : DbContext
{
public ToDoDBContext()
: base("name=ToDoConnectionString")
{
}
public DbSet<ToDo> ToDoes { get; set; }
}

The context class that we are creating should be derived from the DbContext class.
The context class will also keep DbSet of ToDos that will represent the list of ToDo
items being retrieved from the table. The constructor of the context class will pass the
name of connectionString to the base DbContext class. This connectionString
will be used to connect to the database.
Another possibility is to keep the name of the connectionString the same as the
DbContext class name. The Entity Framework will be able to use the corresponding
DbContext class with this connectionString to persist the data. This is an example

of the Convention over configurations principle. However, this is also flexible, so that
we have the possibility of giving custom names to the connectionStrings.
Now to be able to use Entity Framework to persist the data, we just need to create
this connectionString in the XML configuration, and Entity Framework will
take care of creating the database and performing the CRUD operations on their
respective models.

This has shown you how to use the Code First approach using a single model. In
later chapters, you will see how to use multiple models and have relationships
between them, how we can define complex types, and customize models as per our
application requirements.

[ 31 ]

Introduction to Entity Framework

We have looked at how Entity Framework supports various development

approaches and lets us create the conceptual model and data access logic very easily.
We have seen that Entity Framework depends on the EDM to perform the database
CRUD operations, and we have also looked at the various ways to create the
conceptual model and map it to the database using the Database First, Model First,
and Code First approaches.
To fully understand the benefits of Entity Framework over ADO.NET, we must
also look at how easy and efficient it is to use Entity Framework to perform the
actual operations. This will also show how performing CRUD operations is the
same, irrespective of the approach we take. Let's now see how we can perform
CRUD operations using Entity Framework to fully understand the benefits of
Entity Framework.

Performing CRUD operations using

Entity Framework
We will perform CRUD operations on our ToDo model using the Entity Framework
DbContext class.
It doesn't matter which approach we select to create the
database and conceptual model (Database First, Code First, or
Model First); from the code perspective, it's the same code that
the developers need to write in order to use Entity Framework.

Now let's say we have a model for our ToDo item, that is, ToDo. We also have the
DbContext class created to perform CRUD operations on the ToDo model. Let's take a
look at how we can use Entity Framework to perform CRUD operations on our ToDo
model. The important thing to note in these examples would be the use of LINQ. We
will write all our queries in LINQ, and Entity Framework will take care of converting
it to the appropriate SQL and return the results.

Reading a list of items

The way Entity Framework works is that using the DbContext class, we can retrieve
all the data by simply accessing the model collection associated with the view. So, to
fetch a list of items, we just need to get the model collection from the context class:
using(ToDoDBEntities db = new ToDoDBEntities())
{
IEnumerable<ToDo> todoItems = db.ToDos;
}
[ 32 ]

Chapter 1

Let's try to understand the preceding code:

1. We created an object of the DbContext class:
ToDoDBEntities db = new ToDoDBEntities();

2. We then used the DbContext object to fetch the ToDo entities:

IEnumerable<ToDo> todoItems = db.ToDos;

After this call, the list of ToDo items will be available in the ToDo items
collection if we enumerate ToDo items. Entity Framework will internally
perform the following activities for us to fetch the result:
3. Parsed our request for the data.
4. Generated the needed SQL query to perform this action.
5. Used the context class to wire up the SQL to the database.
6. Fetched the results from the database.
7. Created the strongly typed models from the retrieved results and return
them to the user.
If we need to perform eager loading, we can do this by calling
ToList() on the collection as: IEnumerable<ToDo>
todoItems = db.ToDos.ToList();.

Reading a specific item

If we want to retrieve a single item from the model collection, we have many ways
of doing it. Typically, we can use any LINQ function to fetch the single record from
the model collection. Also, if we want to fetch the result using the primary key, we
can use the Find method to do it. Let's look at a few ways in which we can retrieve a
single item using Entity Framework:
using (ToDoDBEntities db = new ToDoDBEntities())
{
ToDo todo1 = db.ToDos.Find(id);
ToDo todo3 = db.ToDos.FirstOrDefault(item => item.TodoItem == "Test
item");
ToDo todo2 = db.ToDos.SingleOrDefault(item => item.TodoItem == "Test
item");

[ 33 ]

Introduction to Entity Framework

Let's try to understand the preceding code:

1. We created an object of the DbContext class:
ToDoDBEntities db = new ToDoDBEntities()

2. Retrieved an item by passing the key values, that is, using the Find function:
ToDo todo1 = db.ToDos.Find(id);

3. Retrieved an item by passing a non-key value using the FirstOrDefault

function:
ToDo todo2 = db.ToDos.SingleOrDefault(item => item.TodoItem ==
"Test item");

4. Retrieved an item by passing a non-key value using the SingleOrDefault

function:
ToDo todo2 = db.ToDos.SingleOrDefault(item => item.TodoItem ==
"Test item");

The FirstOrDefault and SingleOrDefault functions

will return the first occurrence of the item if it is found, else
it will return null. We should always check for the null
values before using the item retrieved using these functions.
SingleOrDefault will throw an exception if it finds multiple
items matching the request criteria.

Creating a new item

To create an item, we simply need to create the model, assign the values in the model
properties, and then call the SaveChanges method on Entity Framework. Now let's
see how we can create a ToDo item using Entity Framework:
using (ToDoDBEntities db = new ToDoDBEntities())
{
ToDo todoItem = new ToDo();
todoItem.TodoItem = "This is a test item.";
todoItem.IsDone = false;
db.ToDos.Add(todoItem);
db.SaveChanges();
}

[ 34 ]

Chapter 1

Let's try to understand the preceding code:

1. We created an object of the DbContext class:
ToDoDBEntities db = new ToDoDBEntities()

2. Created a new ToDo item:

ToDo todoItem = new ToDo();

3. Populated the ToDo item properties with the desired values:

todoItem.TodoItem = "This is a test item.";
todoItem.IsDone = false;

4. Added the item to the context class:

db.ToDos.Add(todoItem);

5. Called Entity Framework's SaveChanges method to persist these changes in

the database:
db.SaveChanges();

Entity Framework's DbContext class is able to identify a new

model and generate the respective insert query for it to create
a new record on the database.

Updating an existing item

To update an existing item, there are two possibilities. The first possibility is that we
will fetch the model, update some of the properties of the model, and then save the
updated model in the database. To do this, we just need to fetch the required model
using the DbContext class, update its properties, and then call the SaveChanges
method on the DbContext object. Let's try to update a model with the ID 3:
using (ToDoDBEntities db = new ToDoDBEntities())
{
int id = 3;
ToDo todo = db.ToDos.Find(id);
todo.TodoItem = "This has been updated";
todo.IsDone = false;
db.SaveChanges();
}

[ 35 ]

Introduction to Entity Framework

Let's try to understand the preceding code:

1. We created an object of the DbContext class:
ToDoDBEntities db = new ToDoDBEntities()

2. Fetched the item with id = 3:

int id = 3;
ToDo todo = db.ToDos.Find(id);

3. Updated the model properties:

todo.TodoItem = "This has been updated";
todo.IsDone = false;

4. Called Entity Framework's SaveChanges method to persist these changes in

the database:
db.SaveChanges();

What is happening in the preceding code is that the DbContext class was still in
scope when the entity was being updated and saved. The DbContext class is able
to track the changes in the entity if it is in scope. However, this approach is rarely
useful, because in real applications in a typical n-tier application, the entities will be
passed through multiple layers, and any layer can update this entity, and at the time
of updating the entity, objects are usually disconnected from the context.
So to perform the updates in such a disconnected environment, we need to attach
the updated entity back to let the DbContext class identify the modifications made
in the entity, and then generate the appropriate update SQL accordingly and persist
the updates in the database. This can be done by attaching the entity back to the
DbContext class. Let's see how a ToDo model can be attached to the DbContext class
if it is being passed from a different tier:
using (ToDoDBEntities db = new ToDoDBEntities())
{
db.Entry(todo).State = EntityState.Modified;
db.SaveChanges();
}

Let's try to understand the preceding code:

1. We created an object of the DbContext class:
ToDoDBEntities db = new ToDoDBEntities()

2. Attached the model to the DbContext class and marked this model
as modified:
db.Entry(todo).State = EntityState.Modified;
[ 36 ]

Chapter 1

3. Called Entity Framework's SaveChanges method to persist these changes in

the database:
db.SaveChanges();

In the preceding code, the ToDo model is being modified and

passed from some other layer. This is a fairly advanced topic
and if it is not clear at this stage, please move on; this will be
covered in detail in further chapters.

Deleting an item
To delete an item, we just need to fetch the item that needs to be deleted, call the
Remove method on the model collection, and call the SaveChanges method on the
DbContext class. Let's try to delete a model with the ID 3:
using (ToDoDBEntities db = new ToDoDBEntities())
{
int id = 3;
ToDo todo = db.ToDos.Find(id);
db.ToDos.Remove(todo);
db.SaveChanges();
}

Let's try to understand the preceding code:

1. We created an object of the DbContext class:
ToDoDBEntities db = new ToDoDBEntities()

2. Fetched the item with id = 3:

int id = 3;
ToDo todo = db.ToDos.Find(id);

3. Removed the item from the collection:

db.ToDos.Remove(todo);

4. Called Entity Framework's SaveChanges method to persist these changes in

the database:
db.SaveChanges();

It is also possible that the model entities are getting created and deleted
while being disconnected from the DbContext class. In these cases, we
need to attach the models to the DBContext class, and mark them using
the EntityState property.
[ 37 ]

Introduction to Entity Framework

Choosing persistence approaches

Now, we saw the three options to create the EDM and the DbContext class. Which
approach should be used in which scenario, is often a question that many developers
ask. There is no definite reason for choosing any particular approach, but here is a
small checklist that the developers might find very useful while deciding on which
approach to choose. If at any point, the answer to any question is yes, then that
approach should be used without even looking at the next question in the checklist:
Question

Approach

Is there a legacy database or does the database already exist?

Database First

Will we be getting a database created by the DBAs before starting the

development?

Database First

Will there be frequent database changes, based on which our

application should change?

Database First

Do we want to use the Visual Entity Designer to generate the database

and model classes?

Model First

Do we have the model classes already and we need the database to

save the data only?

Code First

Do we want to write all the model classes, implement them, and then
think about the database storage later?

Code First

We don't want to deal with the auto-generated classes and would

prefer to write them ourselves

Code First

Is the answer to all the preceding questions "no"?

Database First

Summary
In this chapter, we talked about the ORMs and how ORMs can ease the task of
writing data access code. We saw what Entity Framework is and how it works. We
then saw the various approaches for using Entity Framework. We performed CRUD
operations on a simple model to see Entity Framework in action. Finally, we looked
at which approach would better fit our needs based on the given scenario.
In the next chapter, we will see how we can use the Entity Framework Database First
approach to model complex relationships between database tables as relationships
between the domain models. We will also see how to work with these related models
using Entity Framework.

[ 38 ]

Get more information Mastering Entity Framework

Where to buy this book

You can buy Mastering Entity Framework from the Packt Publishing website.
Alternatively, you can buy the book from Amazon, BN.com, Computer Manuals and most internet
book retailers.
Click here for ordering and shipping details.

www.PacktPub.com

Stay Connected: