The Repository Pattern with EF Code First & MEF

[Edit: new post with demo on the subject http://average-uffe.blogspot.com/2011/06/t4scaffolding-complete-system-from.html]
In this post I will show you how I implement a generic repository pattern with EF Code First as dataprovider, and MEF as the provider for separation of concern.
This post will be quite long since all the source code will be exposed…
If you never heard about MEF, check my previous post for a brief intro http://average-uffe.blogspot.com/2010/10/managed-extensibility-framework.html

A RoadMap (the steps in this tutorial/post…)

• Pre req´s
• Setup the solution
• Create a simple domainmodel (Person and Cars will do).
• Create data and service interfaces (generic and entity-interfaces).
• Implement the geneic repository and the EFCodeFirst DBContext (and entity-repositorys).
• Create our class for handling MEF imports. 
• Implementing the generic ServiceInterfaces and import the exported repository with MEF (and entity-services).
• What have we created? An architectual overview!
• What´s next?

Pre Req´s

• Visual Studio 2010 (Sp1 beta atleast).
• SqlExpress.

Setup the solution

Create 5 projects… 4 Class Library project and one MVC3 WebApp… install MVC if needed.
The classlibraries will represent Core (the domainmodel), Data (the repository), Services (the implementation of serviceinterfaces) and Common for some utilities….

The Data-project will export interfaces so we setup a postbuild event in Visual Studio to copy the dll to our pluginfolder.

Run Nuget PackageManager on Core and Data-projects for EFCodeFirst (run the command twice.. one for Core and one for Data).

Create a simple domainmodel

Finally some coding We will create three POCO classes. One abstract baseclass for common properties such as key, createdTime and updatedTime. And then our Person and Car classes that will inherit the abstract baseclass.

[DataContract]
public abstract class PersistentEntity
{
    [DataMember]
    [Key]
    public int Id { get; protected set; }

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

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

[DataContract]
public class Car : PersistentEntity
{
    [DataMember]
    [StringLength(15)]
    public string Color { get; set; }

    [DataMember]
    [StringLength(10)]
    public string RegNr { get; set; }

    [DataMember]
    [StringLength(20)]
    public string Brand { get; set; }

    [DataMember]
    public virtual Person Owner { get; set; }
}

[DataContract]
public class Person : PersistentEntity
{
    [DataMember]
    [StringLength(50)]
    public string FirstName { get; set; }

    [DataMember]
    [StringLength(50)]
    public string LastName { get; set; }

    [DataMember]
    [StringLength(12)]
    public string SSN { get; set; }
        
    [DataMember]
    public DateTime Birthdate { get; set; }

    [DataMember]
    public virtual IList<Car> Cars { get; set; }
}

Create Data & Service-Interfaces

Above we created the simple domainmodel and now we will create the interfaces for the repository and the service. To understand the reason to why we need interfaces is important! The interfaces data and service may very well have the same signature, but we will need them both to separate and hide the datainterfaces from being exposed further than to the servicelayer. Since we are using MEF the interfaces is also important because we tell MEF that we export the interface (and also that we want to import anything that implements a certain interface).
We will have baseinterfaces for both data and service by using Generics.

The RepositoryInterface

public interface IRepository<T>
{
    IEnumerable<T> GetAll();
    T GetById(int id);
    int SaveOrUpdate(T entity);
    bool Delete(T entity);
}

Above we defined the basic CRUD operations for all entities.. Now we have a very simple implementation of the entities in our domainmodel, displayed below.

Definition for the domainmodels datainterfaces

interface IPersonRepository : IRepository<Person>
{
}

interface ICarRepository : IRepository<Car>
{
}

Thats it… Now we will do the same thing for the serviceinterfaces…

The ServiceInterface

public interface IService<T>
{
    IEnumerable<T> GetAll();
    T GetById(int id);
    int SaveOrUpdate(T entity);
    bool Delete(T entity);
}

public interface ICarService : IService<Car>
{
}

public interface IPersonService : IService<Person>
{
}

Implement the geneic repository and the EFCodeFirst DBContext

In our Data-project we will implement the repositoryinterfaces that we created in the Core-project. We start with the baserepository.
To start, we only create the abstract class called baserepository and implemt the stubs for IRepository<T> (shown below)

public abstract class BaseRepository<T> : IRepository<T> where T : PersistentEntity
{
    public IEnumerable<T> GetAll()
    {
        throw new NotImplementedException();
    }
    public T GetById(int id)
    {
        throw new NotImplementedException();
    }
    public int SaveOrUpdate(T entity)
    {
        throw new NotImplementedException();
    }
    public bool Delete(T entity)
    {
        throw new NotImplementedException();
    }
}

Nothing existing in that class… Since we want to use EFCodeFirst we now need to tell our repository how to handle the CRUD operations. To start we add a new class (DemoContext) that implements the DBContext. This is the class that will tell EFCodeFirst what entities to include in the mapping.

public class DemoContext : DbContext
{
    public DbSet<Person> Companies { get; set; }
    public DbSet<Car> Employments { get; set; }

    public DemoContext() : base("XlentDemoDB")
    {        
        //DropAndReCreate if in debug and model is changed.
        if (System.Diagnostics.Debugger.IsAttached)
            DbDatabase.SetInitializer(new DropCreateDatabaseIfModelChanges<DemoContext>());
    }
        
    public ObjectContext ObjectContext()
    {
        return ((IObjectContextAdapter)this).ObjectContext;
    }
}

Now we have a context to work with… Lets use it in our repository… And that will give us a new verison of the stubb of the repository above.

Repository Implementing our DbContext

Okay, this is alot of code in a post but this is the biggest class in this example… And quite important to… This handles all CRUD operations regardless of the entity as long as the entity inherits the “PersistentEntity” class. Note that we use the export attribut to expose the class to MEF.

[Export(typeof(IRepository<>))]
public abstract class BaseRepository<T> : IRepository<T> where T : PersistentEntity
{
    protected DemoContext Ctx;
    protected string EntitySetName { get; set; }
    protected string ContainerName { get; set; }
    protected ObjectContext ObjectContext { get; set; }
    protected Type CurrentType { get; set; }

    protected BaseRepository()
    {
        //Setup context
        this.Ctx = new DemoContext();

        //Get The ObjectContext to be able to work with generics.
        this.ObjectContext = this.Ctx.ObjectContext();

        //Attach the SavingChanges event.
        this.ObjectContext.SavingChanges += (sender, e) => BeforeSave(this.GetChangedOrNewEntities());

        //Get EntityName and ContainerName
        this.EntitySetName = this.ObjectContext.CreateObjectSet<T>().EntitySet.Name;
        this.CurrentType = typeof(T);
    }

    private IEnumerable<PersistentEntity> GetChangedOrNewEntities()
    {
        const EntityState newOrModified = EntityState.Added | EntityState.Modified;
        return this.ObjectContext.ObjectStateManager.GetObjectStateEntries(newOrModified)
            .Where(x => x.Entity != null).Select(x => x.Entity as PersistentEntity);
    }

    public void BeforeSave(IEnumerable<PersistentEntity> entities)
    {
        foreach (var entity in entities)
        {
            entity.Updated = DateTime.Now;
            entity.Created = !IsPersistent(entity) ? DateTime.Now : entity.Created;
        }
    }

    private static bool IsPersistent(PersistentEntity entity)
    {
        return entity.Id != 0;
    }

    public virtual int SaveOrUpdate(T entity)
    {
        if (IsPersistent(entity))
            this.Ctx.Set(this.CurrentType).Attach(entity);            
        else
            this.Ctx.Set(typeof(T)).Add(entity);            

        return this.Ctx.SaveChanges();
    }

    public virtual T GetById(int id)
    {
        return this.Ctx.Set(this.CurrentType).Find(id) as T; 
    }

    public virtual IEnumerable<T> GetAll()
    {
        return this.ObjectContext.CreateObjectSet<T>(this.EntitySetName);
    }
    public virtual bool Delete(T entity)
    {
        try
        {
            this.Ctx.Set(this.CurrentType).Remove(entity);
            return true;
        }
        catch
        {
            return false;
        }
    }
}

Now that we have the baserepository in place we can create really simple Repositorys for our Person and Car entities…

The PersonRepository

[Export(typeof(IPersonRepository))]
public class PersonRepository : BaseRepository<Person>, IPersonRepository
{        
}

[Export(typeof(ICarRepository))]
public class CarRepository : BaseRepository<Car>, ICarRepository
{
}

If needed you can override the baseclass methods in teh implementations since the baseclass methods is virtual…

Create our class for handling MEF imports

In our repository we export interfaces, and in the servicelayer we want to import the exports… To be able to do this we will write a class that looks for exports in a predefined catalog (remember the postbuild event that copies the dll to our plugin catalog?)… We call the MEF class for Composable and make it abstract…

public abstract class Composable
{
    protected CompositionContainer CompositionContainer { get; set; }
    protected AggregateCatalog AggregateCatalog { get; set; }
    protected IList<string> DirectoryCatalogs { get; set; }

    protected Composable()
    {
        this.DirectoryCatalogs = new List<string>();

        this.AggregateCatalog = new AggregateCatalog();

        //Create the catalog to look for plugins in...
        this.AddDirectoryCatalog(ConfigurationManager.AppSettings.Get("MefDirectoryCatalog"));

        //Add the catalog to the hostcatalog...                        
        this.Compose();
    }

    protected void AddDirectoryCatalog(string catalog)
    {
        this.DirectoryCatalogs.Add(catalog);
    }

    public void Compose()
    {
        //Add Catalogs
        foreach (var directoryCatalog in this.DirectoryCatalogs)
        {
            this.AggregateCatalog.Catalogs.Add(new DirectoryCatalog(directoryCatalog));
        }

        //Create compositioncontainer catalog export/import.
        this.CompositionContainer = new CompositionContainer(this.AggregateCatalog);

        //And... Compose it... :)              
        this.CompositionContainer.ComposeParts(this);
    }
}

No need to say more about this class than that it will need a config-appsetting with the key “MefDirectoryCatalog” that points to the plugincatalog described in the beginning of the post.

Implementing the generic ServiceInterfaces and import the exported repository with MEF

We do not want a project or dll referens to our datalayer from our servicelayer… This is where MEF does it´s magic. Since we export the repository interfaces we will tell our service to import the interfaces… In that way we do not need to reference the actuall datalayer but only the domainmodel in the Core project…. This gives us a plugable architecture and we can replace EFCodeFirst with a xml repository if we want… As long as the repository implements and exports the interfaces!!!

The BaseService

Just like the BaseRepository we will have a generic abstract class for all services… Although much simpler than the repository class.

public abstract class BaseService<T> : Composable, IService<T> where T : PersistentEntity
{
    //MEF does not allow import on open generics.
    //Workaround by setting this in Ctor of implementing classes.
    //[Import(typeof(IRepository<>))]        
    protected IRepository<T> Repository;

    public virtual IEnumerable<T> GetAll()
    {
        return this.Repository.GetAll();
    }

    public virtual T GetById(int id)
    {
        return this.Repository.GetById(id);
    }

    public virtual int SaveOrUpdate(T entity)
    {
        return this.Repository.SaveOrUpdate(entity);
    }

    public virtual bool Delete(T entity)
    {
        return this.Repository.Delete(entity);
    }
}

Thats our baseservice hiding the repository… The servicelayer would be the place to add bussineslogic, would probably be done in the classes that inherit baseservice.
Now we add PersonService and CarService…

public class PersonService : BaseService<Person>, IPersonService
{
    [Import(typeof(IPersonRepository))]
    protected new IPersonRepository Repository;

    public PersonService()
    {
        base.Repository = this.Repository;
    }
}

public class CarService : BaseService<Car>, ICarService
{
    [Import(typeof(ICarRepository))]
    protected new ICarRepository Repository;

    public CarService()
    {
        base.Repository = this.Repository;
    }
}

Just as the BaseRepository the BaseService has virtual methods if you want to override to do some specific logic…

What have we created? An architectual overview!

Ok… I just want to show the loosely coupled architecture of this solution… All made possible by MEF

As you can see the Service-assmebly has no clue about the Data-assembly, the both just know about the Core and the Interfaces that they implement and export.

What´s next?

My idea was to also export the service interface and import the interfaces from a MVC controller, but I think this is to long already (have you been reading all this )… So if someone want´s me to I´ll write a second post about howto put MVC on top of this and then create a REST api in MVC and use JQuery in some simple examples.
To be continued….

[EDIT 11-05-08] new post on the subject. Contains video and VSIX solutiontemplate. 

_______________________________________________________
Thanks for reading
Regards
Uffe