Question

I’ve been trawling stackoverflow and the internet in general all day about the IRepository pattern trying to better understand it before I try and use it in anger.

From what I’ve read (and please do correct me if I’m mistaken) a repoistory encapsulates access to its aggregate root and child objects exposing a common interface that can then be injected or mocked.

So in the instance where you have your aggregate root object:

class Employee {
    string FirstName;
    string LastName;
    IEnumerable<Address> Addresses;
    IEnumerable<PhoneNumber> PhoneNumbers;
}

Then its child objects:

class Address {
    string BuildingName;
    ...etc
}

class PhoneNumber {
    string PhoneNo;
    ...etc
}

So the repository would look something like:

class EmployeeRepository : IRepository<Employee> {
    Employee Get(id) {
    ...does stuff, builds full Employee object including Addresses/Phone No's and returns
    }
}

But say I dont want to get the whole Employee, say I just want the flat Employee record with FirstName LastName and be able to lazy load in the rest in later. How should this be accomplished? Would it be permissible to have something like:

class EmployeeRepository : IRepository<Employee> {
    Employee Get(id) {
    ...does stuff and builds flat Employee object without Addresses and Phone Numbers
    }

    Employee GetAddresses (Employee emp) {
    ...
    }

    Employee GetPhoneNumbers (Employee emp) {
    ...
    }
}

Is this ok or would I be breaking some sacrosanct DDD rule and burn in developer hell? How is lazy loading supposed to fit this model, again tried searching but all I’ve found is “let NHibernate/Entity Framework/ORM do it for you”.

Thanks in advance.

D.

Answer 1

true lazy loading would mean that you have references to proxy objects in the properties of your aggregate root (and anywhere else in the object graph you wind up loading lazily) that would be smart enough to load the real entity and replace the proxy with it when properties are invoked that require it. using something like castle’s dynamic proxy or linfu’s dynamic proxy are the best way to do this because dynamic proxies are complex beasts that have been well implemented by those guys.

doing what you have suggested requires that your consuming code be aware of what has and hasn’t been loaded and puts the burden on the user to know about the lazy loading and think about it in the client code. with a dynamic proxy, you don’t have to think about it.

really, the best answer, though, is the one you have already found. this is a problem that has been solved by ORMs. use NHibernate and worry about your domain rather than implementing something that is already implemented and well tested and used by tons of other projects. it’s a problem with a lot of nuances and you are better off using what is already out there.