The latest release of Entity Framework CTP4 has some nice but unexpected changes. They introduced DbContext and DbSet to simplify model caching, database provisioning, schema creation and connection management. Here are my top 5 favorite features of the release.

1. Less code and fewer Concepts. The coolest part is the use of convention over configuration. See the Productivity Improvements walk through and Conventions for code first. I like the extra touch that DbContext  will create the database for you if you want. No code to write. Just use the default CreateDatabaseOnlyIfNotExists.
2. Simplified Database Experience. With the introduction of DbContext and DbSet. EF now takes care of database provisioning, schema creation and connection management. Nice! My favorite part is the Interface IDbConnectionFactory to allow creation of your own conventions.
3. Backwards Compatible. Yes, this is a feature when it comes to CTP’s and Betas. Some projects might just throw stuff away or completely change things on you. EF allows you to still use ObjectContext or Data Annotations for advanced scenarios where common conventions don’t work for you.
4. Simplified Configuration Experience. As I mentioned you can use annotations for this but you also have another cool option. DbContext includes a virtual method that can be overridden to do configuration right in the class. This means no need for separate configuration classes now. I definitely like having it all in one place. Much cleaner and easy to read.
5. Testability IDbSet<TEntity> allows you to define an interface that can be implemented by your derived context. This allows the context to be replaced with an in-memory test double for testing.

In addition, I added Inversion of Control (IOC) using Castle Windsor and implemented a repository pattern.

My database generation script and test data now look like this.

databasefactory.Create();
var repository = new HolidayRepository(databasefactory);

//... build up test data for xmas and newyear

repository.Add(xmas);
repository.Add(newYear);

//commit changes
var unitOfWork = new UnitOfWork(databasefactory);
unitOfWork.Commit();

The other interesting part of this sample project is using WCF and EF together and WCF dependency injection using Castle Windsor.

First I setup my interfaces and configuration files for EF and WCF.

[DataContract]
public class Holiday : IEntity
{
    public long Id { get; set; }

    [DataMember]
    public string HolidayName { get; set; }

    [DataMember]
    public DateTime HolidayDate { get; set; }

    [DataMember]
    public ICollection<holidayevent> HolidayEvents {get; set;}
}

[DataContract]
public class HolidayEvent : IEntity
{
    public long Id { get; set; }

    [DataMember]
    public string EventName { get; set; }

    [DataMember]
    public Holiday Holiday { get; set; }

    [DataMember]
    public long HolidayId { get; set; }
}

public HolidayConfiguration()
{
    Property(h => h.Id).IsIdentity();
    Property(h => h.HolidayName).HasMaxLength(1000).IsRequired();

    Relationship(e => e.HolidayEvents).FromProperty(h => h.Holiday);
}

public HolidayEventConfiguration()
{
    Property(e => e.Id).IsIdentity();
    Property(e => e.EventName).HasMaxLength(1000).IsRequired();

    //HolidayId is a FK property and Holiday is a navigation property backed by this FK
    Relationship(e => e.Holiday).FromProperty(h => h.HolidayEvents).HasConstraint((e, h) => e.HolidayId == h.Id);
}

In my .svc file I use a custom factory to do dependency injection

Factory="Castle.Facilities.WcfIntegration.WindsorServiceHostFactory, Castle.Facilities.WcfIntegration"

On startup, I add my HolidayService as a component and add the DatabaseFactory as a parameter. The DatabaseFactory is used to setup my EF Object Context.

container.Register(Component.For<iholidayservice>().ImplementedBy<holidayservices>().DependsOn
    (Property.ForKey("databaseFactory").Eq(databaseFactory)));

A great resource for seeing many of the new features in EF CTP3 is the shrinker project. This is where I found many great examples of property facets and relationships using Entity Framework.

In my initial post I tried out the “Code First” methodology of Entity Framework. Taking the code only experiment a step further, I built a sample WCF service that queries and updates a table for holidays. You can browse and download the project via github.

The console application “HolidayService.GenerateSchema” is very similar to the first post. It’s used to create the initial sqlexpress database and put in some initial test data. I did try out a simple configuration using some best practices from this site.

The WCF service has two methods.


[ServiceContract]
public interface IHolidays
{
[OperationContract]
IList GetHolidayDetails(DateTime startDate, DateTime endDate);

[OperationContract]
int AddHolidayDetails(DateTime date, string name);
}


In the HolidayService I created a HolidayManager class for CRUD operations. It uses a GlobalContext class to build an EF HolidayModel ObjectContext. For example, this is what that GetHolidays method looks like in the manager.


using (holidayContext)
{
var holidayQueryResult = (from h in holidayContext.Holidays
where h.HolidayDate < endDate & h.HolidayDate > startDate select h);

foreach (var item in holidayQueryResult)
{
holidays.Add(item);
}
}


In the GlobalContext class, is where my simple project started to feel some pain. It doesn’t feel right to be using a concrete version of the HolidayModel in the ContextBuilder which returns the ObjectContext. I also don’t like that the sql connection string and connection are all in this class. In another post, I’ll use some of the suggestions below to try to make this area more flexible.


var builder = new ContextBuilder();
builder.Configurations.Add(new HolidayConfiguration());
var connStr = ConfigurationManager.ConnectionStrings["UserDBConn"].ConnectionString;
var connection = new SqlConnection(connStr);
return builder.Create(connection);


Since this is a small project I didn’t go any further to clean up the GlobalContext class. I’ll leave that for next time I look into code only. Below are some links which investigate managing ObjectContext, dynamic models, and using EF in a business architecture.

1. Managing Entity Framework ObjectContext
2. how to create a dynamic model using code only
3. Daniel Wertheim – EfEntityStore
4. Putting Entity framework 4 to use in a business architecture
5. Repository implementation – Entity Framework 4.0: a fresh start

If you are intrested in the code only method check out this walk through. I went through it and built my own application to get a handle on this new feature. Here were the steps I took to get up and running. You will need Visual Studio 2010, SQL, and CTP2 version of EF.

1) Install CTP2 Entity Framework Preview 2

2) Create a new class library project in your solution. This will be for your objects that will get mapped to the database. I named mine “UserSchema”. In this project you are just creating normal classes without any references to EF. Below are the two classes I used for testing. Notice they have no meta tags or any other tags that would be EF specific.

   public class Profile
    {
        public Profile() { }
        public int ID { get; set; }
        public string Title { get; set; }
        public string Description { get; set; }
        public string PermaUrl { get; set; }
        public DateTime Created { get; set; }
        public DateTime? LastSeen { get; set; }
    }

    public class User
    {
        public User() { }
        public int ID { get; set; }
        public string FirstName { get; set; }
        public string LastName { get; set; }
        public string UserName { get; set; }
        public string Password {get; set;}
        public ICollection<profile> Profiles { get; set; }
    }

3) Next create a new class project in your solution for your EF models. I called mine UserManager.Model. I think it is good to make a seperate project as this is going to setup all your class context for connecting to EF. You will also need to add a project reference to the project that has your objects which you want to be mapped in the database and a reference to Microsoft.Data.Entity.CTP and System.Data.Entity.

public class UserModel : ObjectContext
    {
        public UserModel(EntityConnection connection)
            : base(connection)
        {
            DefaultContainerName = "UserModel";
        }

        public IObjectSet User
        {
            get { return base.CreateObjectSet(); }
        }

        public IObjectSet
 Profiles
        {
            get { return base.CreateObjectSet
(); }
        }
    }

4) Create a new console application to automatically generate your database. I called mine “UserManager.GenerateDatabase”. This is the application that will use the object context to autogenerate the database. You can also do specific table configuration and other initialization. You can use a RegisterConfigurations method. The walk through above goes into more detail on that.

var builder = new ContextBuilder();
var connStr = ConfigurationManager.ConnectionStrings["UserDBConn"].ConnectionString;

var connection = new SqlConnection(connStr);

using (var ctx = builder.Create(connection))
{
    if (ctx.DatabaseExists())
        ctx.DeleteDatabase();
     ctx.CreateDatabase();

My project and auto generated tables ended up looking like this:

So after going through this quick setup I got a taste of what is to come. I’m still going to stick with ActiveRecord for my ORM but I think EF will definitly be an option in the future. Also, the code only mode will be a little more comfortable for people who have an ActiveRecord background.

update – Code Only Looking Good (part 2)

update CTP3 – Code First Castle Windsor

Entity Framework blog posts

1. Code Only Announcement
2. Code Only Walk Through Entity FrameWork
3. Code Only Enhancements
4. Even More Code Only Enhancements!