Repository Pattern – Part Three

In my previous posts; part one and part two, I introduced my take on several versions of a repository implementation. I ended up a generic repository with an IQueryable getter and insert, update and delete methods. This is good enough in most scenarios.

But I will break this into two repositories and refer you to Greg Young’s article on repositories. His implementation brings a few benefits…

• Explicit contract
• Flexible implementation of generic internal repository (LINQ, ADO, hql, etc…)

Take 5

I will define the generic repository contract and the explicit customer repository as below:

    public interface IRepository<T>
    {
        IList<T> FindAllBy(ISpecification<T> specification);
        void Insert(T item);
        void Delete(T item);
        void Update(T item);
    }

    public interface ICustomerRepository
    {
        Customer GetCustomerByID(string customerID);
        IList<Order> GetOrdersByCustomerID(string customerID);
        IList<Customer> GetAllCustomers();
        void Insert(Customer customer);
        void Delete(Customer customer);
        void Update(Customer customer);
    }

If you have noticed, the customer repository is the explicit contact which I have started with (See Part 1 of the series). For the keen eye, the original generic repository contract has a specification (criteria) a parameter to filter the requested entities.

Let’s define some specifications. They will be needed to filter customers by name (for the generic inner repository).

    public class AllCustomersSpecification : ISpecification<Customer>
    {
        #region Implementation of ISpecification<in Customer,out Customer>

        public IQueryable<Customer> SatisfyingElementsFrom(IQueryable<Customer> candidates)
        {
            return candidates;
        }

        #endregion
    }

    public class CustomerNameSpecification : ISpecification<Customer>
    {
        private readonly string m_name;

        public CustomerNameSpecification(string name)
        {
            m_name = name;
        }

        #region Implementation of ISpecification<in Customer,out Customer>

        public IQueryable<Customer> SatisfyingElementsFrom(IQueryable<Customer> candidates)
        {
            return candidates.Where(c => c.ContactName == m_name);
        }

        #endregion
    }

Now the implementations of the generic repository and the explicit customer repository. Customer repository is a composition.

    public class Repository<T> : IRepository<T>
    {
        // TODO: to be implemented w/ LINQ, EF, NHibernate, etc...

        #region Implementation of IRepository<T>

        public IList<T> FindAllBy(ISpecification<T> specification)
        {
            throw new NotImplementedException();
        }

        public void Insert(T item)
        {
            throw new NotImplementedException();
        }

        public void Delete(T item)
        {
            throw new NotImplementedException();
        }

        public void Update(T item)
        {
            throw new NotImplementedException();
        }

        #endregion
    }

    public class CustomerRepository : ICustomerRepository
    {
        private readonly IRepository<Customer> m_innerRepo;

        public CustomerRepository()
        {
            m_innerRepo = new Repository<Customer>();
        }
        public CustomerRepository(IRepository<Customer> repository)
        {
            m_innerRepo = repository;
        }

        #region Implementation of ICustomerRepository

        public Customer GetCustomerByID(string customerID)
        {
            return m_innerRepo.FindAllBy(new CustomerIDSpecification(customerID)).First();
        }

        public IList<Order> GetOrdersByCustomerID(string customerID)
        {
            return GetCustomerByID(customerID).Orders;
        }

        public IList<Customer> GetAllCustomers()
        {
            return m_innerRepo.FindAllBy(new AllCustomersSpecification());
        }

        public void Insert(Customer customer)
        {
            m_innerRepo.Insert(customer);
        }

        public void Delete(Customer customer)
        {
            m_innerRepo.Delete(customer);
        }

        public void Update(Customer customer)
        {
            m_innerRepo.Update(customer);
        }

        #endregion
    }

Nice thing about CustomerRepository is that it is a composition of the the generic repository. This means that a change in the implementation of generic repository does not affect the CustomerRepository since this is not inheritance anymore.

I am pretty happy with this so far.

Advertisement

Posted by Altug Sahin on June 6, 2010

http://altugsahin.wordpress.com/2010/06/06/repository-pattern-part-three/