Benny Michielsen

When you install packages in a project using NuGet you probably don’t want to include those in your version control system. When you want to share some code in a blogpost you don’t want to include all the dlls that are referenced by your project since people can install the packages through NuGet.

When you install a package though a file gets added called packages.config containing all information needed by NuGet to find it in the repositories. There’s no out of the box solution though all the hooks are in place. You need to install the package called “NuGet.CommandLine”.

This allows you to issue the nuget command which lets you refer to the packages.config file. Then use your package console manager to issue the following command: “nuget i PathToConfig -o Packages”.

You’ll see all your packages fly by. You can find more info over here.

There’s one more way to implement the sample domain model in the database and that’s a table for each class with all properties. And unfortunatly our luck ends a bit here. Although it’s possible to generate an ERD that looks like what we want to achieve I need to change the domain model.

You get the database model above by using the following mapping code

protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
    modelBuilder.Entity<Movie>()
        .Map(x =>  x.MapInheritedProperties())
        .ToTable("Movies");
    modelBuilder.Entity<Cd>()
        .Map(x => x.MapInheritedProperties())
        .ToTable("Cds");
    modelBuilder.Entity<Book>()
        .Map(x=> x.MapInheritedProperties())
        .ToTable("Books");
 
    base.OnModelCreating(modelBuilder);
}

Pollymorphic associations though are not supported using this inheritance strategy and so you need to omit the collection of products in the category class, bummer.

public class Category
{
    [Required]
    public virtual Guid Id { get; set; }
    [Required]
    public virtual string Name { get; set; }
    //public virtual IList<Product> Products { get; set; }
}

Using the same model as before, we want to store it more in a normalized fashion and in my opinion something that closely resembles a typical inheritance structure in code.

Lets create one table for each entity with only the properties it contains, all other ones are linked through a one to one mapping. To achieve this result you’ll need to create your mappings as illustrated below.

protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
    modelBuilder.Entity<Movie>().ToTable("Movies");
    modelBuilder.Entity<Cd>().ToTable("Cds");
    modelBuilder.Entity<Book>().ToTable("Books");
    base.OnModelCreating(modelBuilder);
}

By default if you apply inheritance in Entity Framework 4.1 the model that will be used is table per Hierarchy. Meaning that this object model:Will be translated to this table in your database:

So we get one table containing all the fields from all the classes in the hierarchy and one additional discriminator column which will be filled with the name of the class. Using that value EF knows what class it needs to create an instance from. Create a mapping for this manually would be done by subclassing DbContext and implement OnModelCreating as illustrated in the following piece of code:

protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
    modelBuilder.Entity<Product>()
        .Map(x => x.ToTable("Products"))
        .Map<Book>(x => x.ToTable("Products"))
        .Map<Movie>(x=>x.ToTable("Products"))
        .Map<Cd>(x => x.ToTable("Products"));
    base.OnModelCreating(modelBuilder);
}

Gave a quick intro on what’s new in entity framework 4.1 to my co-workers. You can get the slides and the code.

If you want to get started documentation is at the moment a bit lacking, there is some info on MSDN but you’ll find more on the ADO.NET team blog, especially this 12 part article.

Yesterday the power tools for Entity Framework 4.1 were released, you can read all about them over here.

There are some features that didn’t make it into Entity Framework code first but that are available if you use one of the “older” approaches, Microsoft is quite open about it, which I think is very honest. You can read about those on the MSDN site as well.

There’s also some material that was available in the latest CTP material but didn’t ship in 1.0. Let’s hope they’ll come in the next release.