LINQ to SQL and the repository pattern

The thing is this, LINQ to SQL is not a true Object Relation Mapper (ORM), it is a data access layer generator. You can make it be an ORM by going deep by hand editing XML files and playing with SqlMetal and whatnot, but where it shines is as a DAL.

The idea behind an ORM is this. You have your SQL database, and your domain objects. To design a database properly, you are going to do things (like normalization) that logically don't translate into a properly designed object model, and vice-versa. This is called "Impedance Mismatch", the role of an ORM is to deal with that mismatch in a clean, effective, and efficient way. The less painful database interaction is almost a secondary thing.

The idea behind a repository is that it encapsulates all persistence logic and dependencies on infrastructure from the rest of your application. When your application needs a Customer object, it shouldn't have to know whether it is coming from SQL Server, MySQL, an XML file, or ASP.NET Membership. Once you have that de-coupling, any changes you make to your persistence story have no effect on the rest of your application.

With that in mind, it gets more clear why he did what he did. LINQ to SQL is used to generate the DAL, but the only thing that should be known about the DAL is the repository, so a translation is made to his domain objects. That way he can refactor his domain model without worrying about his persistence story, and he can refactor his database without worrying about rippling effects through his application. He could also start coding on business logic before deciding on questions like what ORM to use, or even where to store his data.

If he were to use a real ORM (like NHibernate), that mapping code gets handled elsewhere (either in XML or bootstrapping classes). I think LINQ to SQL (and Robs open source DAL, SubSonic) are great projects, but more designed for smaller, two-tier applications where something like the repository pattern is overkill. The storefront is also a good illustration of why the additional complexity of NHibernate can be important. He could have saved himself a lot of code by going with something built to handle that sort of scenario, rather than doing it all manually.

It depends on where the DTOs are defined and how you want to test it. If you use DBML, then LINQ to SQL wants to generate the data objects in the data layer. While LINQ to SQL supports persistance ignorance, it doesn't go out of its way to make it easy. Entity Framework doesn't support it at all.

This means that in the standard model, your data layer is defining all the domain entities, which is tricky if you want to test the user interface/business layers in true isolation from the data layer.

A pragmatic approach might be to use the data object definitions from the data layer in unit tests, but not the data-context (i.e. hide the data-context behind the repository interface, but expose the entity types) - but this is muddying the waters a little, and means your UI, etc. need to strongly reference the data layer. But if you think of this as a "domain model layer which happens to also contain a repository implementation that we may or may not be using" you might justify it.

Keeping completely separate domain entities makes unit testing and inversion of control (IoC) more "pure", but increases the amount of code you have (so double-edged).

Are the generated objects serializable? I had the impression they weren't. It's just a case of isolation as Marc Gravel said above.

What if you switch the repository and have a MySQL, Oracle, XML files, Web service, or whatever data provider (Repository)? You would be tied to the LINQ to SQL assembly to reference the entities, right? Which, ofcourse, you wouldn't want.