Gil Fink's Blog : Data Access

Creating a Many To Many Mapping Using Code First

Gil Fink — Mon, 01 Aug 2011 14:17:19 GMT

Creating a Many To Many Mapping Using Code First

Today I got a question about how to create a many to many mapping using Entity Framework Code First. The question was how to create the mapping with an existing database. Here is an explanation how to achieve that.

Creating Many To Many Mapping

Sometimes there is a need to create a many to many relation in the database. When we want to achieve that we will create a relation table which will hold the primary key from every table in the many to many relation. Here is an example of a simple many to many relation that can exist in a database:

In Code First, when we want to create such a relation all we have to do is to create the relevant entities which will hold an ICollection in each side of the relation and create the relevant DbContext. Here is an example for a many to many relation in Code First:

       public class Person

      {

        public int PersonId { get; set; }

        public string FirstName { get; set; }

        public string LastName { get; set; }

        public ICollection<Course> CoursesAttending { get; set; }

        public Person()

        {

          CoursesAttending = new HashSet<Course>();

        }

      }

      public class Course

      {

        public int CourseId { get; set; }

        public string Title { get; set; }

        public ICollection<Person> Students { get; set; }

        public Course()

        {

          Students = new HashSet<Person>();

        }

      }

      public class SchoolContext : DbContext

      {

        public DbSet<Course> Courses { get; set; }

        public DbSet<Person> People { get; set; }

        public SchoolContext()

          : base("MyDb")

        {

        }

      }

Simple as that. The problem starts when we have an existing database where the column names or the relation name aren’t generated by Code First convention engine. In the previous figure of the database, Code First will generate the column names – Person_PersonId and Course_CourseId which don’t match to the existing table.

Using Code First Fluent API to Create a Many To Many Relation Mapping

So we have a small problem with existing relation tables. We can solve the problem by overriding the OnModelCreating method and adding the mapping using Code First fluent API. Here is an example of such a mapping to solve the previous model’s problem:

      public class SchoolContext : DbContext

      {

        public DbSet<Course> Courses { get; set; }

        public DbSet<Person> People { get; set; }

        public SchoolContext()

          : base("MyDb")

        {

        }

        protected override void OnModelCreating(DbModelBuilder modelBuilder)

        {

          modelBuilder.Entity<Course>().

            HasMany(c => c.Students).

            WithMany(p => p.CoursesAttending).

            Map(

             m =>

             {

               m.MapLeftKey("CourseId");

               m.MapRightKey("PersonId");

               m.ToTable("PersonCourses");

             });

        }

      }

In the OnModelCreating you will use the HasMany to indicate that course has many students and WithMany to indicate that a person can attend a lot of courses. The Map method will tell Code First how to build the relation table with the relevant name (using ToTable mapping) and with the relevant keys (MapLeftKey and MapRightKey).

Summary

Creating a many to many relation with Code First is easy. You need to get used to the fluent API if you have an existing database but the API is self explanatory so it makes your job easier.

Microsoft Entity Framework June 2011 CTP was Released

Gil Fink — Fri, 01 Jul 2011 15:34:00 GMT

Microsoft Entity Framework June 2011 CTP was Released

Yesterday, ADO.NET team released a new EF CTP. If you attended my Sela Dev. Days EF4.1 tutorial day this week you heard about this release and the new features. Here is the list of new features to expect from EF4.2 that you can evaluate with the new EF CTP:

Runtime Features

The Enum data-type. At last we will have support for enums. You can use either the Entity Designer within Visual Studio to model entities that have Enum properties, or use the Code First workflow to define entities that have Enum objects as properties. You can use your Enum property just like any other scalar property, such as in LINQ queries and updates.
Geography and Geometry Spatial data-types which are natively supported by the Entity Framework.
Table-valued functions can be added to entity data models. A table-valued function is similar to a stored procedure, but the result of executing the table-valued function is composable, meaning you can use it as part of a LINQ query.
Stored procedures can now have multiple result sets in your entity data model.
The Entity Framework June 2011 CTP includes several SQL generation improvements.
LINQ queries are now automatically compiled and cached to improve query performance.

Entity Framework Designer Features

The Entity Designer now supports the creation of enums, spatial data-types and table-value functions from the designer surface.
You can now create multiple diagrams for each entity data model. Each diagram can contain entities and relationships to make visualizing your model easier.
The StoreGeneratedPattern for key columns can now be set on an entity Properties window and this value will propagate from your entity model down to the store definition.
Diagram information is now stored in a separate file from the edmx or entity code files.
Batch import for stored procedures as function imports. The result shape of each stored procedure will automatically become a new complex type in your entity model. This makes getting started with stored procedures very easy.
The Entity Designer surface now supports selection driven highlighting and entity shape coloring.

Mode Information About the CTP Release

For further information about the CTP you can go to this link. Pay attention for the Getting the Microsoft Entity Framework June 2011 CTP and the Getting Started sections in the announcement and also to the Uninstalling section.

Here are some CTP walkthroughs that were published in ADO.NET team blog:

Enjoy!

My Sela Dev-Days Experience

Gil Fink — Wed, 29 Jun 2011 01:21:02 GMT

My Sela Dev-Days Experience

Today I finished my Sela Dev. Days experience. Sela Dev. Days is a conference which include 5 days, 15 top experts, 25 session, and a whole lot of attendees (around 600 people registered for this week). If you are not familiar with Sela Dev. Days you can go to the conference’s site. In the conference I had three tutorial days in three different subjects:

ASP.NET MVC 3, EF Code First integration, and Razor: Oh My!
In this one day tutorial I co-operated with Sebastian Pederiva, a senior consultant in Sela. In the day we gave a crash dived into Microsoft Web Platform – including ASP.NET MVC 3, EF, Web Platform Installer, Razor view engine and more. At the beginning session I introduced Microsoft web platform and ASP.NET MVC. Then, I talked about building models and data access layers for MVC applications on top of Entity Framework and in particular with Code First. In the third session I talked about how to work with controllers and about the routing concept in ASP.NET. Sebastian talked about Razor and how to integrate AJAX into MVC applications using the jQuery library.
HTML 5
In this one day tutorial I talked about what to expect out of the coming HTML5 standards, the new HTML5 elements, how to migrate HTML4 applications to HTML5 (here I gave a case scenario and with the help of the attendees we migrated a blog web page to HTML5) and about some of the new HTML5 API such as Geolocation, Web Workers, Web Sockets, Canvas and more.
Entity Framework 4.1 and Code First
In this one day tutorial I co-operated with Ido Flatow, another senior architect in Sela. I delivered four sessions – introduction to ORMs and EF, querying and manipulating data using Entity Framework, Entity Framework internals and Code First. Ido gave a session about Entity Framework in distributed applications.

I want to thank all the attendees that joined me in the days I delivered.
All the demos can be downloaded from here.

How to Configure a Self Referencing Entity in Code First

Gil Fink — Fri, 03 Jun 2011 18:36:00 GMT

How to Configure a Self Referencing Entity in Code First

A few days ago a worker in Sela asked me how to configure a self referencing entity with EF Code First. In this post I’ll show you how to implement that configuration.

Self Reference Scenarios

There are a lot of scenarios that we will want to implement a self reference between an entity to itself. For example, we do that when we want to create hierarchies in our application - an employee entity that has a self reference to his/her manager is a very common scenario for that. When we want to create that behavior in a database all we have to do is to add a foreign key in the table that point to the table primary key and we are done. But how can we do that in EF Code First?

Configure a Self Reference in Code First

In EF Code First we can use the fluent API in order to configure a self reference. Lets jump into an example that will direct you how to make that configuration.
The first thing is the entity:

public class Employee{  #region Properties   public int EmployeeID { get; set; }  public string FirstName { get; set; }  public string LastName { get; set; }   public int? ManagerID { get; set; }  public Employee Manager { get; set; }   #endregion}

As you might notice there is nothing interesting in the entity itself – just a bunch of properties and the reference to the manager which is another employee.
After we have the entity lets create the context:

public class CompanyContext : DbContext{  #region Properties   public DbSet<Employee> Employees { get; set; }   #endregion   #region Ctor   public CompanyContext()    : base("Company")  {  }   #endregion   #region Methods   protected override void OnModelCreating(DbModelBuilder modelBuilder)  {    modelBuilder.Entity<Employee>().      HasOptional(e => e.Manager).      WithMany().      HasForeignKey(m => m.ManagerID);  }   #endregion}

In the context you need to implement the OnModelCreating method in order to configure the self reference. We start the configuration with the HasOptional method that indicate that the employee might have a manager (or else he/she is the CEO). Then, for the manager we configure a many side with the WithMany method. In the end we use the HasForeignKey method to indicate what is the foreign key (which is the ManagerID in the example). That is it.
In order to finish the example I’ve created a database initializer that inserts some data:

public class ExampleInitializer : DropCreateDatabaseIfModelChanges<CompanyContext>{  #region Methods   protected override void Seed(CompanyContext context)  {    var manager = new Employee    {      FirstName = "emp1",      LastName = "emp1",    };    var emp1 = new Employee    {      FirstName = "emp1",      LastName = "emp1",      Manager = manager    };    var emp2 = new Employee    {      FirstName = "emp2",      LastName = "emp2",      Manager = manager    };     context.Employees.Add(emp1);    context.Employees.Add(emp2);    context.SaveChanges();  }   #endregion}

and a console application that run the example:

class Program{  static void Main(string[] args)  {    Database.SetInitializer(new ExampleInitializer());     using (var context = new CompanyContext())    {      var query = context.Employees.Include(e => e.Manager).ToList();      foreach (var employee in query)      {        Console.WriteLine("{0} {1}", employee.EmployeeID, employee.ManagerID);      }    }  }}

Here is a figure of the output:

Summary

Lets sum up, the post includes a running example of how to configure a self reference entity with Code First. I hope it will help you if you get stuck with such a configuration.

Sela SDP Conference Sessions Slide Deck and Demos

Gil Fink — Thu, 17 Mar 2011 14:58:36 GMT

Sela SDP Conference Sessions Slide Deck and Demos

Yesterday Sela SDP Conference ended after 4 intensive days.
In the conference I had two breakout sessions about OData and about Code First in Entity Framework.
First of all I want to thank all the attendees in those sessions. I hope that you had good time and that you enjoyed the sessions and of course the whole conference.
As always I published the sessions slide decks and demos for you to download.
The recording (in Hebrew) of all the conference sessions will be published soon in the conference site so stay tuned.

Using Code First Model Configurations Classes

Gil Fink — Mon, 07 Mar 2011 20:48:56 GMT

Using Code First Model Configurations Classes

In the past I explained how to use the Code First Fluent API in order to configure and shape your EDM during runtime. One of the problems that might raise when you use the Fluent API as I showed in the previous post is that the OnModelCreating method might become bloated and hard to read. This is the time to get familiar with another model configuration option which is built inside Code First.

Model Configurations Classes

When you use Code First you will probably configure the creation of the model in some way. You can use the Code First Fluent API in order to do that. When you use the Fluent API the place that you will use it is the OnModelCreating method in the DbContext class. In very big models that might be a problem. Quickly you will find yourself having a very big and bloated method which holds all the configurations. This is the time for refactoring your code to use model configurations. There are two major classes that you will use: the generic EntityTypeConfiguration and ComplexTypeConfiguration. Both of the classes lives in the System.Data.Entity.ModelConfiguration assembly.

Usage Example

Lets revisit the DbContext from the previous post:

       public class SchoolEntities : DbContext

      {

        #region Ctor 

        public SchoolEntities() :

          base("MySchool")

        {

        }

        #endregion

        #region Properties

        public DbSet<Course> Courses { get; set; }

        public DbSet<Department> Departments { get; set; }

        #endregion

        #region Methods

        protected override void OnModelCreating(ModelBuilder modelBuilder)

        {

          base.OnModelCreating(modelBuilder);

          modelBuilder.Entity<Department>().

            Property(d => d.Name).

            IsRequired().

            HasMaxLength(50);

          modelBuilder.Entity<Department>().

            Property(d => d.DepartmentID).

            HasDatabaseGenerationOption(DatabaseGenerationOption.None);

          modelBuilder.Entity<Department>().

            HasMany(d => d.Courses).

            WithRequired(c => c.Department).

            HasForeignKey(c => c.DepartmentID).

            WillCascadeOnDelete();

          modelBuilder.Entity<Department>().

            Ignore(d => d.Administrator);

          modelBuilder.Entity<Course>().

            Property(c => c.Title).

            IsRequired().

            HasColumnName("Name");      

        }    

        #endregion

      }

If I want to use the EntityTypeConfiguration I’ll create a new class for Department configuration. The class will inherit from EntityTypeConfiguration<Department> and in its constructor I’ll use the Fluent API for configurations. The following code sample shows the DepartmentTypeConfiguration class:

      public class DepartmentTypeConfiguration : EntityTypeConfiguration<Department>

      {

        #region Ctor

        public DepartmentTypeConfiguration()

        {

          Property(d => d.Name).

            IsRequired().

            HasMaxLength(50);

          Property(d => d.DepartmentID).

            HasDatabaseGenerationOption(DatabaseGenerationOption.None);

          HasMany(d => d.Courses).

            WithRequired(c => c.Department).

            HasForeignKey(c => c.DepartmentID).

            WillCascadeOnDelete();

          Ignore(d => d.Administrator);

        }

        #endregion

      }

Now that we have the class we will wire it into the ModelBuilder by using the Add method of its Configuration collection. The following code sample show you how to do that:

      public class SchoolEntities : DbContext

      {

        #region Ctor

        public SchoolEntities() :

          base("MySchool")

        {

        }

        #endregion

        #region Properties

        public DbSet<Course> Courses { get; set; }

        public DbSet<Department> Departments { get; set; }

        #endregion

        #region Methods

        protected override void OnModelCreating(ModelBuilder modelBuilder)

        {

          base.OnModelCreating(modelBuilder);

          modelBuilder.Configurations.Add(new DepartmentTypeConfiguration());

          modelBuilder.Entity<Course>().

            Property(c => c.Title).

            IsRequired().

            HasColumnName("Name");

        }

        #endregion

      }

During runtime we will get the same EDM whether we use the first method with the configurations inside the OnModelCreating method or the second method of EntityTypeConfiguration.

Summary

When you use Code First you get a lot of configuration options. If your model is small you can create all the configurations inside the OnModelCreating method. When the model starts to grow you can use the ModelConfiguration classes in order to divide your implementation to small objects with configuration responsibility.

My SDP Lecturer Interview

Gil Fink — Sun, 27 Feb 2011 21:40:48 GMT

My SDP Lecturer Interview

Last week Sela conducted a live broadcast with trailers to the sessions that will be presented on stage in the SDP conference. The broadcast was recorded if you want to see me “making a fool” of myself in the live broadcast you can watch the recording of my interview here (in Hebrew).
I’m reminding that I’m going to have two sessions:

Creating OData Services with WCF Data Services
Data is a first-class element of every application. The Open Data Protocol (OData) applies web technologies such as HTTP, AtomPub and JSON to enable a wide range of data sources to be exposed over HTTP in a simple, secure and interoperable way. This session will cover explain what is the Open Data Protocol and how to create OData feeds using WCF Data Services.

Not Just a Designer: Code First and Entity Framework
Entity Framework 4 brings many new opportunities for building complex data driven applications. Code First is a new EF capability that provides a code-centric experience for interacting with models and databases. The session will cover several new and future EF features such as Code First, and provide an overview for what to expect from EF in the future.

Also, I’m attending a tutorial day with Ido Flatow and Erez Harari about Entity Framework in Depth and a MVP Panel which is an ask the experts session.

Hope to see you at the conference!

ODAC Entity Framework and LINQ Beta was Released

Gil Fink — Fri, 11 Feb 2011 21:12:23 GMT

ODAC Entity Framework and LINQ Beta was Released

If you use Entity Framework in Oracle environments the following news are for you. Oracle published a Beta release of ODAC (Oracle Data Access Components) that supports Entity Framework.
From Oracle site:
”ODAC Entity Framework and LINQ Beta has arrived! It includes support for Entity Framework, LINQ to Entities, Model-First, Entity Data Model Wizard, and more.
The beta includes the 32-bit Oracle Database client 11.2, which can access Oracle Database server 9.2 and higher. It requires Microsoft Visual Studio 2010 and .NET Framework 4.”
If you want to download the Beta and check it out go to this link.

Enjoy!

Book Review – Entity Framework 4 In Action

Gil Fink — Wed, 26 Jan 2011 14:20:00 GMT

Book Review – Entity Framework 4 In Action

I spent some time lately to read the book “Entity Framework 4 in Action” which was written by several authors – Stefano Mostarda, Marco De Sanctis and Daniele Bochicchio. This book was sent to me by Manning Publications as part of the Manning Early Access Program (MEAP).

What You are Going to Gain from The Book?

The book is all about Entity Framework 4. The authors don’t assume that you are familiar with the technology and they take you to an Entity Framework tour. At the end of the book you will have a lot of Entity Framework knowledge. The flow of the book is great and there are lots of details and hidden gems that can help you whether you are a junior Entity Framework developer and whether you are a senior Entity Framework developer. The authors take you step by step in the Entity Framework path and late chapters rely on previous ones which help you to build the knowledge gradually.

What is Included in The Book?

The book isn’t small – approximately 550 pages and includes 19 chapters and 2 appendices (LINQ appendix and Tip & Tricks appendix). The book is divided into 4 parts which are

Redefining your data access strategy
Working with Entity Framework
Mastering Entity Framework
Applied Entity Framework.

Every part relies on the previous parts and therefore you can’t read the parts as standalone if you are a novice in Entity Framework. If you are a senior Entity Framework developer you can read the parts as standalone but you’ll probably miss some details which are included in previous parts.

Chapter 1: Data access reloaded: Entity Framework
The chapter include a discussion about the ORM world and also about the impedance mismatch which lead to the development of ORMs.
Chapter 2: Getting started with Entity Framework
In the chapter the authors shows and describe how to build the Entity Framework part of an application that will be used across the book. During the chapter you’ll get to know what is Entity Framework and will learn a lot of basic stuff.
Chapter 3: Querying the model: the basics
This chapter is all about the basics of querying the Entity Framework model. You will get to know the ways to do that and what is happening under the hood in the query process.
Chapter 4: Querying with LINQ to Entities
The chapter will explain in details what is LINQ to Entities and how to use it.
Chapter 5: Domain model mapping
This chapter is all about the EDM. You will hand craft the EDM parts manually and will gain valuable knowledge about its XML.
Chapter 6: Understanding entity lifecycle
The chapter describes the entity life cycle and the change tracking mechanism. This is a very important chapter since the details in it are very important to the understanding how Entity Framework is working under the hood.
Chapter 7: Persisting objects into the database
The chapter describe how to perform data manipulations by using Entity Framework.
Chapter 8: Handling concurrency and transactions
As in the chapter name, you will learn how to handle concurrency and transactions with Entity Framework.
Chapter 9: An alternative way of querying: Entity SQL
In this chapter you will learn what is Entity SQL and how to apply in order to query the model.
Chapter 10: Working with stored procedures
This chapter is all about stored procedures and how to use them in Entity Framework environment.
Chapter 11: Working with functions and views
The chapter will explain how to use model defined functions and defining query elements.
Chapter 12: Exploring EDM metadata
In this chapter you will gain the understanding how to use the MetadataWorkspace in order to make runtime EDM metadata queries.
Chapter 13: Customizing code and designer
In the chapter you learn how to customize the code generation by changing the Entity Framework T4 templates. Also you will learn how to extend the Entity Framework designer.
Chapter 14: Designing the application around Entity Framework
The chapter starts with a Domain Driven Design discussion and shows how Entity Framework can help you to design applications which are more Domain Driven.
Chapter 15: Entity Framework and ASP.NET
The chapter will guide you how to use Entity Framework with ASP.NET with EntityDataSource.
Chapter 16: Entity Framework and N-Tier development
The chapter discuss how to include Entity Framework inside N-Tier applications. You will learn about the Self-Tracking entities and how to use DTO design pattern.
Chapter 17: Entity Framework and Windows applications
The chapter will guide you how to use Entity Framework with WPF and WinForms.
Chapter 18: Testing ADO.NET Entity Framework
The chapter starts with a discussion about Unit Testing and explains how to test Entity Framework by using Microsoft Testing Framework.
Chapter 19: Keeping an eye on performance
This chapter is all about performance tuning. I expected more from this chapter but the major things of performance tuning are there.

The Bottom Line

This is a good Entity Framework book and I recommend it especially for junior Entity Framework developers. The book's content is more then enough to get started with Entity Framework and also it is organized well. There are discussions about methodologies like Domain Drive Design and Unit Testing that I really liked which add to the content you are reading and enrich your understanding. The book is doing it job by giving a good deep dive into Entity Framework 4. I give the book 5 stars out of 5.

MIX11 Open Call Voting Has Started Today

Gil Fink — Tue, 25 Jan 2011 14:22:00 GMT

MIX11 Open Call Voting Has Started Today

MIX conference is the biggest Microsoft web conference which occurs every year in Las Vegas. As in every year Microsoft asked the developers and designers communities to propose sessions that will be part of a community voting. The sessions that will be chosen will be performed on stage at this year’s conference. Since I’m going to MIX11 as in last year, I proposed two sessions and they were chosen to the open call voting. This is the session descriptions:

Building Data-Driven MVC Applications with Entity Framework Code First
Entity Framework 4 brings many new opportunities for building complex data driven applications. Code First is a new Entity Framework feature that provides a code-centric experience for interacting with models and databases. In this session we will build a full blown MVC application on top of Entity Framework Code First.
Creating OData Services with WCF Data Services
Data is a first-class element of every application. The Open Data Protocol (OData) applies web technologies such as HTTP, AtomPub and JSON to enable a wide range of data sources to be exposed over HTTP in a simple, secure and interoperable way. This session will cover WCF Data Services best practices so you can use it the right way.

If you find this content interesting I encourage you to go and vote for me and maybe you will hear the session in MIX11. There are other sessions that you can vote to in this link and you can vote up to 10 sessions. The voting will be open up until February 4.
Happy voting!

Building Data Access Layers with Entity Framework Slide Deck

Gil Fink — Mon, 24 Jan 2011 19:49:59 GMT

Building Data Access Layers with Entity Framework Slide Deck

Today I had an Entity Framework session (“Building Data Access Layers with Entity Framework”) session at Microsoft Ra’anana.
I want to thank all the attendees who came to hear the session.
You were a great audience.
In the session I

Introduced EF.
Explained the EDM concept.
Explained how to query the database using EF.
Explained how to make data manipulation using EF.
Talked about EF4 and the major features it brought to the framework.

I published the slide deck and demos in my SkyDrive and you can download it from here.
Enjoy!

Adding Metadata to Entities in The Data Model

Gil Fink — Thu, 20 Jan 2011 19:28:37 GMT

Adding Metadata to Entities in The Data Model

Sometimes I’m being asked how to add metadata to a generated entity in Entity Framework. This metadata can be data annotation or other attributes which can help the developer during runtime. One answer that I give is to edit the T4 template in order to add the attributes. This solution can be combined with the building of an extension to Entity Framework designer which can add more details to the EDM. But it can take some time to develop. Another solution is to create a MetadataType for the entity and use the entity’s partial class behavior to add this type. This post will show you the second solution.

Adding Metadata to a Generated Entity

In the example I’m going to use the following simple entity:

This type is part of a Dynamic Data site and the requirements for it are not to show the TypeID and that the Url needs to be up to 100 characters. Since Dynamic Data work with Data Annotations I want to add this metadata to the entity. But the problem is that the entity is generated by Entity Framework code generation. So how can I add the annotations? using the MetadataType attribute. The MetadataType is an attribute that is part of the System.ComponentModel.DataAnnotations assembly. It indicates that the a data model class has an associated metadata class. The MetadataType attribute gets a type parameter to specify which type is holding the metadata for the class. We can use the fact that the entity is generated as partial class and add the MetadataType attribute to it. Lets look at an example of how to use the MetadataType attribute:

       public class CRMTypeMetadata

      {

          [ScaffoldColumn(false)]

          public int TypeID { get; set; }

          [StringLength(100)]

          public string Url { get; set; }

      }

      [MetadataType(typeof(CRMTypeMetadata))]

      public partial class CRMType

      {

      }

The first thing to notice in the example is that I’ve created a public class by the name CRMTypeMetadata which hold the properties annotated with the relevant attributes. The Metadata postfix in the class name is a convention that I encourage you to use. After I create the metadata class all I need to do is to create a partial class for the generated entity and annotate it with the MetadataType attribute. The MetadataType attribute will get as a parameter the type of the metadata type which is CRMTypeMetadata in the example. That is all.
Now the expected behavior was achieved.

Summary

One of the solutions to add metadata to entities in the Entity Data Model is by using the MetadataType attribute. It is very simple to use and can help you in frameworks like ASP.NET MVC, Dynamic Data, WCF Ria Services and more.

SDP Conference 2011 is Coming

Gil Fink — Mon, 17 Jan 2011 16:14:45 GMT

SDP Conference 2011 is Coming

Sela Developer Practice (SDP) conference will occur between 13 to 16 of March. In this annual conference we (Sela Group) are going to share the current and future Microsoft technologies. The conference will give you a chance to see the best lecturers and leading experts, to be exposed to new technologies and to learn about the Microsoft products that have been launched last year. This is of course an opportunity to meet with colleagues from different organizations and to share knowledge.

In the conference I’m going to have a session about Code First in Entity Framework and to attend the MVP Panel which is an ask the experts like session. Also, I’m taking a part in an very interesting Entity Framework seminar along with Ido Flatow and Erez Harari. In the seminar we are going to talk about O/RM as a concept, explore Entity Framework as an O/RM solution and talk about best practices for using Entity Framework in applications. This is going to be fun.

There are other tutorials and sessions that are very recommended so if you want to be a part of the conference you can go to the conference web site – SDP.
See you there.

Entity Framework 4 Session

Gil Fink — Sun, 02 Jan 2011 17:51:49 GMT

Entity Framework 4 Session

Lately I wasn’t blogging or working because of a very annoying virus. I’m feeling better now so don’t worry I’ll return blogging gradually. I also wanted to tell you about an open house I’m having at Microsoft about Entity Framework 4. The session will take place at Microsoft’s office at Ra’anana in Monday 24 of January. In the session I’m going to introduce Entity Framework and then what’s new in Entity Framework 4. For more details and for registration you can go to the following link.

See you there!

EF Feature CTP5: Inheritance Scenarios with Code First Fluent API

Gil Fink — Sun, 12 Dec 2010 17:29:30 GMT

EF Feature CTP5: Inheritance Scenarios with Code First Fluent API

One of the interesting features of Code First fluent API is the ability to configure inheritance in your model. Since one of the strengths of an O/RM solution is its ability to map inheritance then this feature is a must in every mapping scenario (may it be Model first, Database First or Code First). In this post I’ll show how to configure inheritance by using the fluent API.

Revisiting Entity Framework Inheritance Types

In the past I wrote a series of posts about inheritance mapping in Entity Framework which you can read here:

Configure Inheritance Using Code First Fluent API

In the previous CTPs in order to create inheritance we had to use the MapHierarchy method which was very tedious. In this version the MapHierarchy method was replaced by the Map method (and not in all the inheritance mapping scenarios you’ll need to use it). Lets explore the inheritance types:

Table per type (TPT) inheritance
In order to create this type of mapping all you have to do is to use the ToTable method:

       public class Course

      {

        #region Properties

        public int CourseID { get; set; }

        public string Title { get; set; }

        public string Days { get; set; }

        public DateTime Time { get; set; }

        public string Location { get; set; }

        public int Credits { get; set; }    

        #endregion

      }

      public class OnLineCourse : Course

      {

        #region Properties

        public string CourseURL { get; set; }

        #endregion

      }

      public class SchoolEntities : DbContext

      {

        #region Properties

        public DbSet<Course> Courses { get; set; }

        #endregion

        #region Methods

        protected override void OnModelCreating(ModelBuilder modelBuilder)

        {

          modelBuilder.Entity<Course>()

            .ToTable("Courses");

          modelBuilder.Entity<OnLineCourse>()

           .ToTable("OnLineCourses");

        }

        #endregion

      }

You start with creating the inheritance in the model itself (OnLineCourse inherit from Course) and then in the DbContext’s OnModelCreating method you specify that every type will be mapped to its own table using the ToTable method.

Table per hierarchy (TPH) inheritance
In order to create this type of mapping you need to use the Map method. In the lambda the Map method gets you write the discriminator field and its values using the Requires and HasValue methods. In the following example you can see how to do exactly that:

      public class Course

      {

        #region Properties

        public int CourseID { get; set; }

        public string Title { get; set; }

        public string Days { get; set; }

        public DateTime Time { get; set; }

        public string Location { get; set; }

        public int Credits { get; set; }    

        #endregion

      }

      public class OnLineCourse : Course

      {

        #region Properties

        public string CourseURL { get; set; }

        #endregion

      }

      protected override void OnModelCreating(ModelBuilder modelBuilder)

      {

        modelBuilder.Entity<Course>()

          .Map(c =>

          {

            c.Requires("Discriminator").HasValue(1);

          })

          .Map<OnLineCourse>(olc =>

          {

            olc.Requires("Discriminator").HasValue(2);

          });

      }

Table per concrete type (TPC) inheritance
In order to create this type of mapping you will start as it is a table per type inheritance configuration. The only change is the use of the Map method on the concrete type. In the method lambda you will use the MapInheritedProperties method to indicate it is a concrete type:

      public class Course

      {

        #region Properties

        public int CourseID { get; set; }

        public string Title { get; set; }

        public string Days { get; set; }

        public DateTime Time { get; set; }

        public string Location { get; set; }

        public int Credits { get; set; }    

        #endregion

      }

      public class OnLineCourse : Course

      {

        #region Properties

        public string CourseURL { get; set; }

        #endregion

      }

      protected override void OnModelCreating(ModelBuilder modelBuilder)

      {

        modelBuilder.Entity<Course>()

          .ToTable("Courses");

        modelBuilder.Entity<OnLineCourse>()

         .Map(olc =>

         {

           olc.MapInheritedProperties();

         }).ToTable("OnLineCourses");

      }

Here is a simple check to see how the database is created in each inheritance type:

      using (SchoolEntities context = new SchoolEntities())

      {

        context.Database.Delete();

        var course = new Course

        {          

          Credits = 2,

          Days = "MF",

          Location = "Class 1",

          Time = DateTime.Now,

          Title = "Entity Framework",

        };

        var onLineCourse = new OnLineCourse

        {          

          Credits = 3,

          Days = "WT",

          Location = "Class 2",

          Time = DateTime.Now,

          Title = "Entity Framework On Line",

          CourseURL = "http://www.gilfink.net",

        };

        context.Courses.Add(course);

        context.Courses.Add(onLineCourse);

        context.SaveChanges();

Pay attention that in the TPC inheritance the database will be created properly and the insert will succeed but there will be an exception of overlapping keys (both courses will be created with CourseID of 1 and in the context there will be overlapping).

Summary

Using the Code First fluent API for inheritance is easy. In the post I showed how you can do that using the three main inheritance scenarios in Entity Framework.