The Entity Data Model uses the following three types of XML files to represent the C-Space, C-S Space, and the S-Space respectively.

These files store the metadata information as XML for each of the above layers. Here is what the CSDL section of your Entity Data Model looks like:

<!-- CSDL content -->
<edmx:ConceptualModels>
<EntityContainer Name="PayrollEntities">
<EntitySet Name="Designation" EntityType="PayrollModel.Designation" />
</EntityContainer>
<EntityType Name="Designation">
<Key>
<PropertyRef Name="DesignationID" />
</Key>
<Property Name="DesignationID" Type="Int32" Nullable= "false" />
<Property Name="DesignationName" Type="String" Nullable="false" MaxLength="50" Unicode="false" />
<NavigationProperty Name="Employee" Relationship= "PayrollModel.FK_Employee_Designation" FromRole="Designation" ToRole="Employee" />
</EntityType>
</edmx:ConceptualModels>

Here is how a typical SSDL section of the Entity Data Model looks like:

<!-- SSDL content -->
<edmx:StorageModels>
<EntityContainer Name="dbo">
<EntitySet Name="Designation" EntityType= "PayrollModel.Store.Designation" />
</EntityContainer>
<EntityType Name="Designation">
<Key>
<PropertyRef Name="DesignationID" />
</Key>
<Property Name="DesignationID" Type="int" Nullable="false" StoreGeneratedPattern="Identity" />
<Property Name="DesignationName" Type="varchar" Nullable="false" MaxLength="50" />
</EntityType>
</Schema>
</edmx:StorageModels>

And here is the C-S maping section for you:

<!-- C-S mapping content -->
<edmx:Mappings>
<Mapping Space="C-S" xmlns="urn:schemas-microsoft-com:windows:storage:mapping:CS">
<EntityContainerMapping StorageEntityContainer="dbo" CdmEntityContainer="PayrollEntities">
<EntitySetMapping Name="Designation">
<EntityTypeMapping TypeName="IsTypeOf(PayrollModel.Designation)">
<MappingFragment StoreEntitySet="Designation">
<ScalarProperty Name="DesignationID" ColumnName= "DesignationID" />
<ScalarProperty Name="DesignationName" ColumnName= "DesignationName" />
</MappingFragment>
</EntityTypeMapping>
</EntitySetMapping>
</EntityContainerMapping>
</Mapping>
</edmx:Mappings>
</edmx:Runtime>
</edmx:Edmx>

We will skip further discussion on each of the sections of an Entity Data Model until Chapter 3.

When working with the ADO.NET Entity Framework, you will have an Object Model on top of all the Entity Data Model layers. You need to model the Object Model using .NET objects. The following figure illustrates how the Object Model fits in with the EDM layers:

The Object Model Layer contains, .NET objects, collection of .NET objects, types, properties and methods. You can use the Object Model or the O-Space Model to query your business objects, or the collections of your business objects, using LINQ to Entities or Entity SQL. The C-Space and O-Space models are actually mapped by the O-C Mapping Layer using code attributes applied to the O-space Model.

Language Integrated Query (LINQ) is a query translation pipeline that has been introduced as part of the C# 3.0 library. It comprises a set of query operators for different data sources (LDAP, Objects, CSV, XML, Entities, SQL, etc.). It is an extension of the C# language and provides a simplified framework for accessing relational data in a strongly typed, Object Oriented manner.

LINQ to Entities is a Microsoft technology that enables you to query your business objects from within the language in a strongly typed manner. You can use LINQ to Entities, a superset of LINQ to SQL, to query data against a conceptual data model, namely, the Entity Data Model. We will learn more on LINQ and LINQ to Entities in the chapter 6.

Here is an example of a typical LINQ to Entities query:

PayrollModel.PayrollEntities ctx = new PayrollModel.PayrollEntities();
var query = from emp in ctx.Employee
select emp;
foreach (var employee in query)
Response.Write("<BR>"+employee.FirstName);

Entity Client, the gateway to entity-level queries, is the Entity Framework's counterpart of ADO.NET's SQL Client or Oracle Client that uses Entity SQL or E-SQL to query the conceptual model. You create a connection using Entity Connection, execute commands through Entity Commands, and retrieve the result sets as Entity Data Readers.

Entity SQL is a data store independent derivative of T-SQL that supports entity inheritance and relationships. You can use it to query data using the conceptual schema. You can even build your own dynamic queries. These E-SQL queries are internally translated to data store dependent SQL queries. This translation, that is, the conversion of the E-SQL queries to their data store-specific query language like T-SQL, (it doesn't need to be only T-SQL, however, it is the supported one) is handled by the Entity Framework. Entity SQL or E-SQL may not be as strongly typed as LINQ is, but, you have the flexibility of executing dynamic queries using it, much like T-SQL.

But, why do you need Entity SQL when you have LINQ to Entities to query data through you Entity Data Model? You can, using Entity SQL, compose queries that are difficult to determine until the time the query is executed. On a different note, Entity SQL is a full text-based query language that you can use in much the same way as you use ADO.NET data providers.

Here is an example that shows how you can use Entity SQL to insert data in your applications.

using (EntityConnection conn = new EntityConnection("Name=PayrollEntities"))
{
try
{
conn.Open();
EntityCommand cmd = conn.CreateCommand();
cmd.CommandText = "PayrollEntities.AddNewEmployee";
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("FirstName", "Joydip");
cmd.Parameters.AddWithValue("LastName", "Kanjilal");
cmd.Parameters.AddWithValue("Address", "Hyderabad");
cmd.Parameters.AddWithValue("DepartmentID", 4);
cmd.ExecuteNonQuery();
}
catch (Exception ex)
{
Response.Write(ex.ToString());
}
}

Select Employee.FirstName, Employee.LastName, Department.DepartmentName, Salary.Basic
from Employee
INNER JOIN
Department on Department.DepartmentID = Employee.DepartmentID
INNER JOIN
Salary on Salary.EmployeeID = Employee.EmployeeID

Select FirstName, LastName, DepartmentName, Basic from EmployeeData

Apart from querying the Conceptual Model, you might, at some point, have to work with entities such as in-memory objects or a collection of in-memory objects. To do this you need Object Services. You can use it to query data, from almost any data store, with less code. In addition to from enabling you to perform CRUD operations, the Object Services Layer provides the following additional services:

We will learn more about Object Services later in the book. The Object Services Layer internally uses an Object Query object for query processing. Note that the Object Services Layer supports querying data using both Entity SQL and LINQ to Entities.

Here is an example that shows how you can use Object Services to retrieve data.

using (ObjectContext ctx = new ObjectContext("Name=PayrollEntities"))
{
var query = from employee in ctx.CreateQuery<PayrollModel.Employee>("PayrollEntities.
Employee") select employee;
foreach (PayrollModel.Employee emp in query)
{
Response.Write("<BR>" + emp.FirstName);
}
}

Here is a quick look at some of the features and benefits of the ADO.NET Entity Framework: