Entity Framework CTP 4.0 – Data Fetching

In the last two posts I have discussed about Entity Framework CTP 4.0 Code First Approach and Database Initialization.Now we will take a look at how to define relationships and navigational properties between the Entities and how data fetching is impacted by these.

We will consider two tables Course and Department as example.

These tables are modeled as the following entity classes.

public class Course
{
    public int CourseID { get; set; }
    public string Title { get; set; }
    public int Credits { get; set; }
    public Department Department { get; set; } 

}
public class Department
{
    public int DepartmentID { get; set; }
    public string Name { get; set; }
    public decimal  Budget { get; set; }
    public DateTime StartDate { get; set; }
    public int Administrator { get; set; }
    public ICollection<Course> Courses { get; set; }
} 

Then the entity configuration and database context classes are defined as shown below:

public class CourseConfig:EntityConfiguration<Course>
  {
      public CourseConfig()
      {
          MapSingleType(
                          a =>
                              new 
                              {
                                  a.CourseID,
                                  a.Title,
                                  a.Credits,
                                  a.Department.DepartmentID
                              }
                       ).ToTable("dbo.Course"); 

          HasKey((a) => a.CourseID); 

          Property(a => a.Title).IsRequired();
      }
  }
  public class DepartmentConfig : EntityConfiguration<Department>
  {
      public DepartmentConfig()
      {
          MapSingleType(
                          a =>
                              new
                              {
                                  a.DepartmentID,
                                  a.Name,
                                  a.StartDate,
                                  a.Administrator,
                                  a.Budget
                              }
                       ).ToTable("dbo.Department"); 

          HasKey((a) => a.DepartmentID);
          Property(a => a.Name).IsRequired();
      }
  } 

public class SchoolDBContext:DbContext
{
    public SchoolDBContext(DbModel model,string name) : base(name,model ) { }
    public DbSet<Course> Courses { get; set; }
    public DbSet<Department> Departments { get; set; } 

    public ObjectContext ObjectContext
    {
        get
        {
            return base.ObjectContext;
        }
    }
}

 

Now let’s try to fetch data into Course and Department object using the following code:

static void Main(string[] args)
    {
        Database.DefaultConnectionFactory = new
            SqlConnectionFactory("Server=SANKARSAN;Database=School;Trusted_Connection=True;MultipleActiveResultSets=True"); 

        ModelBuilder builder = new ModelBuilder();
        builder.Configurations.Add(new CourseConfig());
        builder.Configurations.Add(new DepartmentConfig());
        DbModel model = builder.CreateModel(); 

        using (var context = new SchoolDBContext(model, "school"))
        {
            Database.SetInitializer<SchoolDBContext>(null);
            foreach (var c in context.Courses)
            {
                Console.WriteLine("Course Title: {0}",c.Title);
                Console.WriteLine("Credits: {0}",c.Credits);
                Console.WriteLine("Department : {0}",c.Department.Name);
                Console.WriteLine("----------------------------------");
            }
        }
        Console.Read();
    }
} 

 

The values for Department are not getting populated.

So where lies the problem?.By default Lazy Loading is enabled for DbContext.Ideally it should fetch the Department record corresponding to that Course.

This has nothing do with CTP 4.0.In EF 4.0, Lazy Loading of POCO entities needs a proxy class which is dynamically generated at runtime.This class inherits from the entity classes( Course & Department in this case) and overrides the navigational properties to load data.So I need to mark the navigational properties as virtual.I had missed this while creating my entity classes.Once these are marked the program works perfectly fine and loads the data for Department entity lazily.We can see the dynamic proxy using quick watch window:

How to turn off lazy loading and enable eager loading?

DbContext class wraps the System.Data.Objects.ObjectContext class exposes it as a protected property.I have used the same in SchoolDBContext class as ObjectContextProperty.

    public new ObjectContext ObjectContext
    {
        get
        {
            return base.ObjectContext;
        }
    } 

We can turn off lazy loading in the following way:

context.ObjectContext.ContextOptions.LazyLoadingEnabled = false; 

When lazy loading is turned off we can either go for explicit loading using ObjectContext.LoadProperty as shown below:

if (c.Department == null) context.ObjectContext.LoadProperty<Course>(c, x => x.Department); 

To do eager loading we need to use the Include extension methods on System.Linq.IQueryable<T>.In CTP 4.0 a new overload of extension method Include is added which allows us to pass a LINQ expression as shown below:

foreach (var d in context.Departments.Include<Department>(d=>d.Courses))
{
    Console.WriteLine("Name: {0}", d.Name);
    Console.WriteLine("Start Date: {0}", d.Budget);
    foreach (var c in d.Courses)
    {
        Console.WriteLine("Course : {0}", c.Title);
    }
    Console.WriteLine("----------------------------------");
}