Gil Fink's Blog : XML

Defining Custom Functions in Entity Framework

Gil Fink — Fri, 01 Jan 2010 21:00:46 GMT

Defining Custom Functions in Entity Framework

During the SDP conference
I have been asked about the
use of functions inside the EDM.
This post will try to answer one
such question of how to define
a custom function in EF.

Custom Functions in Entity Framework

One of the capabilities of EF since EF1 was the creation of custom
functions inside the SSDL part of the model. After their creation
we could consume them like other imported functions.
In that way we could define functions in the model which were
acting like stored procedures but without being a part of the database.
This of course means that in order to use this feature we needed to
write some XML code inside the SSDL.

Defining a Custom Function

The first thing to do is to open the model in XML editor and to
add a Function element inside the Schema element in the SSDL part of the
XML. Inside the Function element we add a CommandText element which
will hold our T-SQL expression. We can also add to the function parameters.
The following XML fragment shows an example of a custom function:

     <Function Name="GetCoursesByCredit" IsComposable="false">

      <CommandText>

        SELECT *

        FROM Course

        WHERE Credits = @Credits

      </CommandText>

      <Parameter Name="Credits" Type="int" Mode="In"></Parameter>

    </Function>

After the creation of that function we can use the Add Function Import
wizard to import that function to the ObjectContext:

and then to run a test like this one to see the function in action:

    using (var context = new SchoolEntities())

    {

        var query = context.GetCoursesByCredit(3);

        foreach (var course in query)

        {

            Console.WriteLine(course.Title);

        }

        Console.ReadLine();

    }

Summary

EF enables us to add custom SSDL functions to our model. These
functions can be handled like other imported functions (UDFs or
stored procedures). This feature should be used rarely in my opinion
and only when there is a T-SQL functionality that we must have but
EF doesn’t support.

Reading a Xml File in T4 Templates

Gil Fink — Sat, 12 Dec 2009 18:46:47 GMT

Reading a Xml File in T4 Templates

After I wrote the
post about the
use of T4 templates
in EF4, I played with
them for a while (not
in EF but generally with
T4 templates).
In an old project that
I’ve created almost 3 years ago
which automated the use of lookup tables I had an enum.
That enum was meant to be the connection between an Xml
node names and was heavily used in the application.
For each Xml node I needed to add an entry in the enum.
So I thought what the hell lets see if I could have make it using
a T4 template. The result is in the post.

Reading a Xml File in T4 Templates

The first thing to do is to add a new file with the extension of
.tt into the project. After I had that T4 template file I started to
think what is the way to read an Xml file from the T4. Since the
Xml file was a part of the project the use of Path class to get the
absolute location was one way to get the file.
Pay attention that if you will open the solution from the IDE and
not from its location (double click on the solution from its current
location) the Path.GetFullPath won’t work.
After I had the file it was as simple as to read a Xml using
XmlDocument and XPath query.
The following example is the T4 I have created:

     <#@ template language="C#" #>

    <#@ assembly name="System.Core" #>

    <#@ assembly name="System.Xml" #>

    <#@ import namespace="System.Xml" #>

    <#@ import namespace="System.Collections.Generic" #>

    <#@ import namespace="System.IO" #>

    using System;

    namespace Examples

    {

        public class ExampleClass

        {

            #region Enums

            public enum eExampleEnum

            {

    <#

        foreach (string name in this.GetNames())   

        {

    #>

        <#= name #>,

    <# 

        }

            #>

            }

            #endregion

        }

    }

    <#+

        public List<string> GetNames()

        {

            List<string> result = new List<string>(); 

            XmlDocument doc = new XmlDocument();

            string absolutePath = Path.GetFullPath("File.xml");                

            doc.Load(absolutePath);

            foreach (XmlNode node in doc.SelectNodes("/Root/Element"))

            {

                result.Add(node.Attributes["Name"].InnerText);

            }

            return result;

        }

    #>

Summary

The use of T4 template can help us to generate code using
a code generation tool. In the example I showed how you can use
a T4 template in order to generate an enum from a given Xml file.

Enabling Xml Schema Validation in Visual Studio

Gil Fink — Tue, 10 Mar 2009 17:43:50 GMT

Enabling Xml Schema Validation in Visual Studio

The post is a simple tip
which will help you to
enable Xml schema
validation and intellisense
while writing an Xml file
inside Visual Studio.

The Problem

Writing Xml files according to a specific Xml schema definition is
sometime very hard and can be a very “painful” task for a developer.
You need to remember all the small details and elements in order to do it
properly. So how can we validate the Xml files while writing them?

The Solution

Having the Xsd file which can validate your schema during the writing
of the Xml file can be very helpful. Also, getting hints and intellisense
about Xml properties, elements and errors while writing the Xml file
can increase the writing speed of the file.
Visual Studio include this feature you just need to know how to enable
it and use it.

Step 1

Add a namespace to your schema file. For example the following
schema fragment has a “urn:schema-namespace” namespace:

     <xs:schema targetNamespace="urn:schema-namespace" xmlns="urn:schema-namespace" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:NS="urn:schema-namespace">

        <!-- Your schema definitions goes here -->

    </xs:schema>

Having the namespace is a must because in Visual Studio you’ll
have to give the schema namespace to the Xml file you write.

Step 2

Put the Xsd file in the following directory while Visual Studio is
closed:
$Visual Studio Directory$\Xml\Schemas
(Replace the $Visual Studio Directory$ with the location of your
Visual Studio)

Step 3

Open Visual Studio and start writing your Xml file. Remember that you
have to give the namespace of the schema in order to have schema
validations and intellisense inside Visual Studio.
The following example is using the schema namespace from step 1:

    <?xml version="1.0" encoding="utf-8" ?>

    <root xmlns="urn:schema-namespace">

      <!-- write here your Xml -->

    </root>

Summary

Lets sum up, I showed a very helpful tip of how to enable Xml
schema validation and intellisense through Visual Studio. I use this
feature a lot when I write Xml files which have schema files.
I hope this tip will help you too.

Back to Basics – Zip in .NET

Gil Fink — Fri, 06 Feb 2009 01:47:28 GMT

Back to Basics – Zip in .NET

In today’s post I’m
going to share a
problem I solved this
week. The solution was
to use the framework’s
System.IO.Compression namespace and the GZipStream object.

The Problem

In my current project we save Xml data in our database. The field to
save the data was of type varchar(6000). This way of saving the data raised
a problem of big Xml data (over 8000 kb for every Xml data)
which were saved in the database and for the long run could raise
space and performance problems.

The Solution

Use the compression abilities of .NET framework, compress the
Xml data and save the data in a binary form. We needed to change the
field type in the database to binary type and compress the Xml data
before inserting it to the database. After the binary data was retrieved
from the database a reverse process of decompress returns the
original Xml string.

The Code

I first built a console application to write the code and test it.
Then, I wired the zip and unzip methods I wrote to the part that needed
the compression. The following code is the console application’s
zip and unzip methods I used to compress the Xml data.

      
            static void Main(string[] args) 

            { 

                string data = "<Root><Child></Child>data1<Child>data2</Child><Child>data3</Child><Child>data4</Child><Child>data5</Child></Root>"; 

                Console.WriteLine(data); 

                byte[] zipped = ZipDocumentData(data); 

                Console.WriteLine(Encoding.UTF8.GetString(zipped)); 

                data = UnZipDocumentData(zipped); 

                Console.WriteLine(data); 

                Console.Read(); 

            } 

            private static byte[] ZipDocumentData(string documentData) 

            { 

                byte[] byteArray = Encoding.UTF8.GetBytes(documentData); 

                string result = string.Empty; 

                using (MemoryStream ms = new MemoryStream()) 

                { 

                    using (GZipStream stream = new GZipStream(ms, CompressionMode.Compress)) 

                    { 

                        //Compress 

                        stream.Write(byteArray, 0, byteArray.Length); 

                    } 

                    return ms.ToArray(); 

                } 

            } 

            private static string UnZipDocumentData(byte[] zippedDocumentData) 

            {             

                string result = string.Empty; 

                //Prepare for decompress 

                using (MemoryStream ms = new MemoryStream(zippedDocumentData)) 

                { 

                    using (GZipStream stream = new GZipStream(ms, CompressionMode.Decompress)) 

                    { 

                        //Reset variable to collect uncompressed result 

                        byte[] byteArray = new byte[4096]; 

                        //Decompress 

                        int rByte = stream.Read(byteArray, 0, byteArray.Length); 

                        result = Encoding.UTF8.GetString(byteArray); 

                    } 

                } 

                return result; 

            }

Some things that should be concerned if you are going to use this code:

The encoding of the strings I use are in UTF8 format. If you use other
formats you should change the Encoding.UTF8 code to the format you
use.
In the decompress process I use a fixed array of 4096 bytes. This is only
for the testing application in the real method I save the original size of
the array.

Summary

Lets sum up, I used a compression method to compress Xml data in the
database. I showed the code to do that using the GZipStream object which
is part of System.IO.Compression namespace. I hope the code will help you
when you’ll ever need to compress data.

How to Write Your Own Code Snippets

Gil Fink — Sat, 17 Jan 2009 15:09:35 GMT

How to Write Your Own Code Snippets

IntelliSense code snippets
are a very useful tool for
developers in order to write
code faster.In the post I’m
going to describe how to
write your own code snippet and to show an example of a code snippet that
I wrote which divides classes by regions in the style that I like.

What are Code Snippets?

IntelliSense code snippets are basically Xml files that have a strict schema
and have a .snippet file name extension. They are used by developers for
faster code writing and therefore can reduce the time it takes to code.
When you locate a code pattern that always repeat itself in some varieties
you should consider writing it in a code snippet in order to save time.
Code snippets are also used by lecturers in order to write faster code in
their sessions (using the IntelliSense) in order to reduce the amount
of technical coding that they write and reduce problems that may occur.

Writing Your Own Code Snippet

Building a code snippet is easy. All you have to do is to follow the
code snippet XML schema. The first thing to do is to create a new
Xml file with the .snippet file name extension. After you have that
file you need to follow the code snippet XML schema in order to create
your snippet. In the file the first thing to add is the CodeSnippets element
with a Xml namespace to direct to the snippets namespace like this:

     <CodeSnippets xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">

      <CodeSnippet Format="1.0.0">

      </CodeSnippet>

    </CodeSnippets>

After you wrote the namespace it will help you to create the snippet
by showing errors of missing Xml elements that you need to provide.
Every snippet has to have a snippet header. The header provide the details for
the snippet such as the Title, the Author, the Description and the Shortcut
which is the code you write to invoke the snippet in the IntelliSense.
An example for a header can look like:

    <Header>

      <Title>

        Arrange Class Snippet

      </Title>

      <Author>Gil Fink</Author>

      <Description>The snippet helps to divide a class to its parts using regions</Description>

      <Shortcut>ArrangeClass</Shortcut>      

    </Header>

The last element that we have to include in the Xml is the Snippet itself.
The main element of the Snippet element is the Code element which inside
of it you provide the snippet code. You have to indicate which language the
snippet belongs (C#, VB or more). The code of the snippet needs to be
located inside of a <![CDATA[ …Code ]]> element.
An example of a Snippet element can look like:

    <Snippet>      

      <Code Language="CSharp">

        <![CDATA[#region Consts

                 #endregion

                 #region Members

                 #endregion

                 #region Properties

                 #endregion

                 #region Ctor

                 #endregion

                 #region Methods

                 #region API Public Methods

                 #endregion

                 #region Private Methods

                 #endregion

                 #endregion]]>

      </Code>

    </Snippet>

The following example is a code snippet that I wrote to help me arrange
classes to regions in the way that I like. This is a full example for how to
write a code snippet:

    <?xml version="1.0" encoding="utf-8"?>

    <CodeSnippets xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">

      <CodeSnippet Format="1.0.0">

        <Header>

          <Title>

            Arrange Class Snippet

          </Title>

          <Author>Gil Fink</Author>

          <Description>The snippet helps to divide a class to its parts using regions</Description>

          <Shortcut>ArrangeClass</Shortcut>      

        </Header>    

        <Snippet>      

          <Code Language="CSharp">

            <![CDATA[#region Consts

                     #endregion

                     #region Members

                     #endregion

                     #region Properties

                     #endregion

                     #region Ctor

                     #endregion

                     #region Methods

                     #region API Public Methods

                     #endregion

                     #region Private Methods

                     #endregion

                     #endregion]]>

          </Code>

        </Snippet>

      </CodeSnippet>

    </CodeSnippets>

How to Import a Code Snippet into the Code Snippet Manager?

After writing a code snippet the next thing to do is to import it to the
Code Snippet Manager of Visual Studio. The following steps will help you
to do this thing:

In Visual Studio choose Tools menu and from it the Code Snippet
Manager:
From the Code Snippet Manager choose your language of choice and
press the Import button.

A dialog will be opened and in it browse the file system and find
your snippet. This will open the Import Code Snippet dialog.

In the Import Code Snippet dialog choose where to put the snippet
and you are done.

Summary

Lets sum up, in the post I introduced code snippets. I also showed
how to write your own code snippet and then how to import it to
Visual Studio 2008’s Code Snippet Manager. Code snippets can reduce
the amount of coding time by writing patterns of code into a code snippet
fragment and then use that fragment through the IntelliSense.
The following link is a good place to start when you want to get more
information about code snippets:
creating and using IntelliSense code snippets.

How And Why To Use DefiningQuery Element

Gil Fink — Thu, 15 May 2008 02:03:00 GMT

How And Why To Use DefiningQuery Element

In the last post in the entity framework series I introduced the
EDM designer. Today I'm going to show how to do things that
the designer isn't able to perform (for the ADO.NET's team notice).
You should be familiar with the EDM XML schema types and the general
elements before you start to read this post. If you didn't read my post about
the subject you can read it in the following link.

DefiningQuery Element Intoroduction
Today's topic will be the DefiningQuery element.
DefiningQuery elements are defined in the SSDL. These elements are created
when you map a database view in the EDM wizard. These mappings are read
only a projection of data and therefore read only like database views.
By now you probably ask yourself why I'm writing about these elements.
The great thing about DefiningQuery elements are that they can help us
create every projection that we like and with the EDM designer we can then
create entities to handle the created view.
So what is great about what I wrote if the element gives us a read only data?
By connecting the created entity of the CSDL to stored procedures you
can add a write functionality to the defined query.
The drawback of this method is that you need to do it manually in the SSDL.
Also, you don't have intellisense while writing the query so I suggest that you
try it first in the database management studio and then move it to the SSDL file.
You should be very careful when you define queries in the SSDL!

DefiningQuery Element Example
In the next example I'll continue using the database and example from my previous
post. The database schema is shown in the next figure:

The current state of the designer is shown in the next figure:

How to define a DefiningQuery element?
First, write the query for the data projection.
The query I'm going to use will select details from two tables - Employees
and Companies.

SELECT e.EmpolyeeID AS EmpolyeeID,
              e.EmployeeFirstName AS EmployeeFirstName,
              e.EmployeeLastName AS EmployeeLastName,
              c.CompanyName AS CompanyName
FROM Employees AS e INNER JOIN Companies AS c ON (e.CompanyID = c.CompanyID)

Open the edmx file with XML editor and look for the SSDL area.
Insert a new EntitySet to the SSDL with the DefiningQuery element.
In the example I inserted a new entity set with the name of
EmployeeWithCompany:

<EntitySet Name="EmployeeWithCompany" EntityType="TestLINQModel.Store.EmployeeWithCompany">
   <DefiningQuery>
   SELECT e.EmpolyeeID as EmpolyeeID,
   e.EmployeeFirstName AS EmployeeFirstName,
   e.EmployeeLastName AS EmployeeLastName,
   c.CompanyName AS CompanyName
   FROM Employees AS e INNER JOIN Companies AS c ON (e.CompanyID = c.CompanyID)
   </DefiningQuery>
</EntitySet>

After you inserted the new EntitySet you need to provide a new
entity type which is called in my example EmployeeWithCompany.
You can see that the entity set reference this type.
The entity type should look like:

<EntityType Name="EmployeeWithCompany">
   <Key>
      <PropertyRef Name="EmpolyeeID" />
   </Key>
   <Property Name="EmpolyeeID" Type="int" Nullable="false" StoreGeneratedPattern="Identity" />
   <Property Name="CompanyName" Type="nvarchar" MaxLength="100" />
   <Property Name="EmployeeFirstName" Type="nvarchar" MaxLength="50" />
   <Property Name="EmployeeLastName" Type="nvarchar" MaxLength="50" />
</EntityType>

Pay attention to define the property elements exactly as their definition
in the database (type and constraints). It's done manually and therefore
you can have errors.

After these operations the projection of the data is ready to use in the
CSDL. Open the designer and create a new entity with the
EmployeeWithCompany name. Add four properties to the entity to
match the properties of the entity type that was defined in the SSDL.
Your designer surface should look like the next figure:

After the creation of the entity we need to connect it to the created view
and its properties. You do it by selecting the view name in the Tables column
of the Mapping View and by mapping the relevant entity set properties to
the entity properties.
The result:

Build the solution and you are set to use the new read only entity.

What is Next to Come
In the next post I'll show how you can map the entity to stored procedures
to enable insert, update and delete operations and by that to unleash the power
of DefiningQuery element.

Schema Definitions Of EDM In Entity Framework

Gil Fink — Sat, 26 Apr 2008 15:24:00 GMT

Schema Definitions Of EDM In Entity Framework

On the previous post about the entity framework I wrote about the
entity data model (EDM) and explained how to add a one to one mapping
model to your application.
Today I'm going to explain a little about the bits and bites of the new
XML schema types which describe the models.

The Schema Types
The EDM is divided into three models (as explained in my previous post) - the
conceptual, the mapping and the logical model.
Every model has it's own XML schema type:

Store Schema Definition Language (.ssdl) schema type -
The schema describes the database tables and relations between them.
Mapping Specification Language (.msl) schema type -
The schema describes the mapping between the conceptual model (csdl)
and the logical model (ssdl).
Conceptual Schema Definition Language (.csdl) schema type -
The schema describes the objects and their relations.

The Example Model
Lets look at a picture of the example I'm going to show:

I use two tables from a database - Companies and Employees.
The example will help me explain the relevant parts in the schema files of the EDM.
You should note that the example is a simple one to one mapping.

Store Metadata - SSDL Example

<?xml version="1.0" encoding="utf-8"?>
<Schema Namespace="CompaniesModel.Store" Alias="Self" 
  ProviderManifestToken="09.00.3054" 
  xmlns="http://schemas.microsoft.com/ado/2006/04/edm/ssdl">
  <EntityContainer Name="dbo">
    <EntitySet Name="Companies" EntityType="CompaniesModel.Store.Companies" />
    <EntitySet Name="Employees" EntityType="CompaniesModel.Store.Employees" />
    <AssociationSet Name="FK_Employees_Companies" 
       Association="CompaniesModel.Store.FK_Employees_Companies">
      <End Role="Companies" EntitySet="Companies" />
      <End Role="Employees" EntitySet="Employees" />
    </AssociationSet>
  </EntityContainer>
  <EntityType Name="Companies">
    <Key>
      <PropertyRef Name="CompanyID" />
    </Key>
    <Property Name="CompanyID" Type="bigint" Nullable="false" 
       StoreGeneratedPattern="Identity" />
    <Property Name="CompanyName" Type="nvarchar" MaxLength="100" />
    <Property Name="CompanyAddress" Type="nvarchar" MaxLength="100" />
    <Property Name="CompanyPhone" Type="nvarchar" MaxLength="50" />
  </EntityType>
  <EntityType Name="Employees">
    <Key>
      <PropertyRef Name="EmpolyeeID" />
    </Key>
    <Property Name="EmpolyeeID" Type="bigint" Nullable="false" 
       StoreGeneratedPattern="Identity" />
    <Property Name="CompanyID" Type="bigint" />
    <Property Name="EmployeefirstName" Type="nvarchar" MaxLength="50" />
    <Property Name="EmployeeLastName" Type="nvarchar" MaxLength="50" />
    <Property Name="EmployeeJobTitle" Type="int" />
    <Property Name="EmployeePhone" Type="nvarchar" MaxLength="50" />
  </EntityType>
  <Association Name="FK_Employees_Companies">
    <End Role="Companies" Type="CompaniesModel.Store.Companies" 
       Multiplicity="0..1" />
    <End Role="Employees" Type="CompaniesModel.Store.Employees" 
       Multiplicity="*" />
    <ReferentialConstraint>
      <Principal Role="Companies">
        <PropertyRef Name="CompanyID" />
      </Principal>
      <Dependent Role="Employees">
        <PropertyRef Name="CompanyID" />
      </Dependent>
    </ReferentialConstraint>
  </Association>
</Schema>

The schema define the namespace to use for the store definition which is
CompaniesModel.Store.
Then you can see that the schema is built from three main elements -
the EntityContainer element, the EntityType elements and the Association elements.

The EntityContainer is the definition of all the elements and their associations.
Every EntityType is reference by an EntitySet and every Association is referenced by
AssociationSet. You can see that the association set is using the entity sets defined
earlier and also using the Roles which will be defined later in the Association elements.

The EntityType elements are the definition of every table in the database.
Every EntityType has a Key element that describe the primary key of the current
element. Also every EntityType has Property elements that describe the fields in the
database. For every Property there is a set of attributes which include it's name and
database type and also constraints like MaxLength or Nullable which are taken
from the database.

The Association elements are the definition of the foreign keys between the tables
in the database. Every Association define the end points of the foreign key by
using the End elements. Every End element is built from its Role, its type which is the
table it's connected to and its Multiplicity which define the the number of entities
that can exist on each side of a relationship (cardinality).
There is also the ReferentialConstraint that define the fields that are used in the
association. The ReferentialConstraint is built from Dependent elements which describe
the property that is used from the EntityType.

Mapping Specification - MSL Example

<?xml version="1.0" encoding="utf-8"?>
<Mapping Space="C-S" xmlns="urn:schemas-microsoft-com:windows:storage:mapping:CS">
  <EntityContainerMapping StorageEntityContainer="dbo" 
     CdmEntityContainer="CompaniesEntities">
    <EntitySetMapping Name="Companies">
      <EntityTypeMapping TypeName="IsTypeOf(CompaniesModel.Companies)">
        <MappingFragment StoreEntitySet="Companies">
          <ScalarProperty Name="CompanyID" ColumnName="CompanyID" />
          <ScalarProperty Name="CompanyName" ColumnName="CompanyName" />
          <ScalarProperty Name="CompanyAddress" ColumnName="CompanyAddress" />
          <ScalarProperty Name="CompanyPhone" ColumnName="CompanyPhone" />
        </MappingFragment>
      </EntityTypeMapping>
    </EntitySetMapping>
    <EntitySetMapping Name="Employees">
      <EntityTypeMapping TypeName="IsTypeOf(CompaniesModel.Employees)">
        <MappingFragment StoreEntitySet="Employees">
          <ScalarProperty Name="EmpolyeeID" ColumnName="EmpolyeeID" />
          <ScalarProperty Name="EmployeefirstName" ColumnName="EmployeefirstName" />
          <ScalarProperty Name="EmployeeLastName" ColumnName="EmployeeLastName" />
          <ScalarProperty Name="EmployeeJobTitle" ColumnName="EmployeeJobTitle" />
          <ScalarProperty Name="EmployeePhone" ColumnName="EmployeePhone" />
        </MappingFragment>
      </EntityTypeMapping>
    </EntitySetMapping>
    <AssociationSetMapping Name="FK_Employees_Companies" 
         TypeName="CompaniesModel.FK_Employees_Companies" StoreEntitySet="Employees">
      <EndProperty Name="Companies">
        <ScalarProperty Name="CompanyID" ColumnName="CompanyID" />
      </EndProperty>
      <EndProperty Name="Employees">
        <ScalarProperty Name="EmpolyeeID" ColumnName="EmpolyeeID" />
      </EndProperty>
      <Condition ColumnName="CompanyID" IsNull="false" />
    </AssociationSetMapping>
  </EntityContainerMapping>
</Mapping>

The msl schema define the relation between the ssdl schema and the csdl schema.
The main element is the EntityContainerMapping which connect the ssdl container
(the StorageEntityContainer) and the csdl container (the CdmEntityContainer).
The mapping between tables and entities are based on the EntitySetMapping elements.
The mapping between foreign keys and entity relations are based on the
AssociationSetMapping elements.

The EntitySetMapping element has a main element which is the EntityTypeMapping.
The EntityTypeMapping has a type name which was described in the csdl file. That
type name is mapped to the one or more MappingFragment which describe the store entity set.
This way of definition enable us to map entities to more then one table as will be shown
in the next posts I'm going to write.
Also there is a mapping for every property in the csdl to its property in the store
definition by the ScalarProperty element.

The AssociationSetMapping element maps the store entity set which was defined in the
ssdl file to the relation that was defined in the csdl file. The TypeName attribute describe
the name of the csdl relation and the StoreEntitySet describe the name of the
ssdl association. Every EndProperty element is the mapping between the End elements
in the ssdl to the End elements in the csdl. The Condition is the constraint which in our case
CompanyID shouldn't be null in order for the association to be valid.

Conceptual Schema - CSDL Example

<?xml version="1.0" encoding="utf-8"?>
<Schema Namespace="CompaniesModel" Alias="Self" 
  xmlns=http://schemas.microsoft.com/ado/2006/04/edm>
  <EntityContainer Name="CompaniesEntities">
    <EntitySet Name="Companies" EntityType="CompaniesModel.Companies" />
    <EntitySet Name="Employees" EntityType="CompaniesModel.Employees" />
    <AssociationSet Name="FK_Employees_Companies" 
       Association="CompaniesModel.FK_Employees_Companies">
      <End Role="Companies" EntitySet="Companies" />
      <End Role="Employees" EntitySet="Employees" />
    </AssociationSet>
  </EntityContainer>
  <EntityType Name="Companies">
    <Key>
      <PropertyRef Name="CompanyID" />
    </Key>
    <Property Name="CompanyID" Type="Int64" Nullable="false" />
    <Property Name="CompanyName" Type="String" MaxLength="100" />
    <Property Name="CompanyAddress" Type="String" MaxLength="100" />
    <Property Name="CompanyPhone" Type="String" MaxLength="50" />
    <NavigationProperty Name="Employees" 
       Relationship="CompaniesModel.FK_Employees_Companies" 
       FromRole="Companies" ToRole="Employees" />
  </EntityType>
  <EntityType Name="Employees">
    <Key>
      <PropertyRef Name="EmpolyeeID" />
    </Key>
    <Property Name="EmpolyeeID" Type="Int64" Nullable="false" />
    <Property Name="EmployeefirstName" Type="String" MaxLength="50" />
    <Property Name="EmployeeLastName" Type="String" MaxLength="50" />
    <Property Name="EmployeeJobTitle" Type="Int32" />
    <Property Name="EmployeePhone" Type="String" MaxLength="50" />
    <NavigationProperty Name="Companies" 
       Relationship="CompaniesModel.FK_Employees_Companies" 
       FromRole="Employees" ToRole="Companies" />
  </EntityType>
  <Association Name="FK_Employees_Companies">
    <End Role="Companies" Type="CompaniesModel.Companies" 
       Multiplicity="0..1" />
    <End Role="Employees" Type="CompaniesModel.Employees" 
       Multiplicity="*" />
  </Association>
</Schema>

The schema describe the namespace for the conceptual model which is CompaniesModel.
As in the ssdl schema the csdl schema is divided into three main elements -
the EntityContainer element, the EntityType elements and the Association elements.

The EntityContainer is the definition of all the entities and their relations.
Every EntityType is reference by an EntitySet and every Association is referenced by
AssociationSet. You can see that the association set is using the entity sets defined
earlier and also using the Roles which will be defined later in the Association elements.

The EntityType element is the definition of every entity.
Every EntityType has a Key element that describe the primary property of the current
element (The entity ID). Also every EntityType has Property elements that describe its
properties. For every Property there is a set of attributes which include it's name and
.Net type and also constraints like MaxLength or Nullable.
There is an element called NavigationProperty that describe relations between
entities. In our example every employee works in a company which is another entity
in the schema. The FromRole and ToRole describe the direction of the relation which
will be described in the Association element (one to one, one to many, many to many).

The Association element is the definition of the relations of the entities.
Every Association define the end points of the relation by using the End elements.
Every End element is built from its Role, its type which is the
entity it's connected to and its Multiplicity which define the the number of entities
that can exist on each side of a relationship (cardinality).

Summary
Let sum up what I showed in the post.
I described the three models which construct the EDM and the XML schema types.
I showed simple examples for every schema file and described important key
features in the files. I didn't show stored procedure mapping or mapping of one entity
to many tables. These subjects will be explained in the next posts.

As you can understand, the mission of manually writing the schema files is very
complicated but if you want to understand the entity framework you should be
familiar with them.
In the next post about the entity framework I'm going to explain how to work with
other features the framework provides.