ThoughtShapes - Where Should My Repository Live? - Comments

Thank you for taking the

Anonymous — Mon, 19 Nov 2007 22:01:51 -0500

Thank you for taking the time to respond. Everything you said makes perfect sense, and it is nice to have this type of validation when coding DDD.

I believe passing the Repository to the constructor makes more sense because we should argue that the Customer does not have the “knowledge” to know which repository to create, and therefore it is logical for CustomerFactory to do this job (and it works better with unit tests). So I agree with all your point.

At this point, I am trying to use NHibrante to implement a prototype on this idea. When I am done, I will post it on my blog (http://mikeperetz.blogspot.com/) I would love your feedback on it.

Thanks for the complement on

Rob Scott — Mon, 19 Nov 2007 12:19:00 -0500

Thanks for the complement on the article.

You raise an interesting (and common) problem. If I were to implement lazy loading here to deal with the customer who had placed a million orders I would allow the Customer class to interact with an interface to an order repository (IOrderRepository). It would obtain an implemenation of that interface by calling a repository factory object to get the concrete implemenation and then use that to retrieve a smaller subset of the data. Using your example of a date range I would implement the customer get order method like so:

public class Customer
{
      IList GetOrders(DateTime from, DateTime to)
      {
           return RepositoryFactory.OrderRepository.GetOrders(this, from, to);
       }
}

Now since the Customer class is really referring to an IOrderRepository, I'd say that the Repository interface lives in the domain (with its client), and the concrete implementations live in their own namespaces (and probably assemblies).

Note that although I'm using a RepositoryFactory in this example, I might provide the indirection by just passing the IOrderRepository to the Customer when I created it. (This implies that whatever object created the Customer object would get the concrete implementation from the RepositoryFactory because we still want that run-time configurability.) I usually determine whether or not to pass the repository instances to the object on its constructor or have it use the RepositoryFactory directly based upon whether the object uses multiple repositories. If it uses one or two different repositories, I pass the instances, otherwise I just have the object use the RepositoryFactory to get the instances.

Does that make sense to you?

First of all, you wrote a

Anonymous — Sun, 18 Nov 2007 10:10:13 -0500

First of all, you wrote a very nice article. I think you are touching very fundamental issues. I am studying DDD now, and having trouble with a few scenarios.

Where do Repositories live? I feel that I am very limited if the repositories live within the Application layer only. I think lazy loading becomes a must in one point, because you don’t want to bring too much data from the database.

I also feel, that if you were to implement Specification pattern (Evens), then again you need the Repositories. Having said that, I think you should only use interfaces to them, and never use their true implementation.

When coding I sometime have a “the million rule”, what if there is a million orders to a customer. Or what if there are a million history records for a transaction. We should never bring that type of data down. We should probably use Query Pattern, which will work with Repositories.

Now I wonder, if I was to create a Customer and Order classes… does this makes snese?

List orders = customer.GetOrders(); // use Repository to implement this
Or
List order = customer.GetOrders(DateTime fromDate) // use Repository with Query pattern

What about adding an order?
customer.AddNewOrder(order);

Does code like that is DDD? If yes, the Repositories do live within the domain…

What is your take on this?
(Let’s assume that you can have a million orders per customer)

Where Should My Repository Live?

Rob Scott — Mon, 19 Mar 2007 13:20:00 -0400

Adherents to Domain Driven Design (DDD) often struggle with how to structure the “layers” of their application with respect to where object repositories should be placed. As usual in software development the answer to this quandary is “It depends”. In this posting I’ll discuss several things that should be taken into consideration when making this decision.