ASP.NET MVC (Domain Model, Repository, Fluent, Services - Structure for my Project)
.net, asp.net-mvc, c#, dependencies, project-structure
Solution
I would look at the article by Jeffrey Palermo on the Onion Architecture here. This basic architecture works well in any project and will allow you to separate your core project (domain layer, persistence, etc.) from your web project.
We use this with MVC/StructureMap/FluentNHibernate and have had great success.
We end up having a structure similar to the one below.
> trunk
+ build (build scripts)
+ lib (external libraries)
> src (source code)
>> Organization.App (solution name)
>> Organization.App.Core (code library)
+ Config
> Domain
> Model
> Persistence
> Queries
> Services
> Persistence
> Services
>> Organization.App.Web (mvc web app)
> Assets
+ Images
+ Scripts
+ Stylesheets
+ Controllers
+ Views
+ ViewModels
That's the basic idea. The web app references the core app for domain entities our repository/unit of work. Check out this older project on google code for a similar example. The great part about this is we have been able to add new "UI" project types to the same solution and re-use our core project as intended. Like a console app or a second web app, or whatever you need.
Problem
In my ASP.NET MVC web application, I have: Domain Model, created by LINQ to SQL Repositories such as `UserRepository` and `OrderRepository` IQueryable Fluents as IQueryable Extension Methods such as `public IQueryable<Order> GetNewOrders(this IQueryable<Order>)` Services such as `UserService` and `OrderService` Utility Classes and Extension Methods such as `CryptoUtility` (doing Hashing etc.) and String etc. extensions ViewModels which are special for each MVC View The ASP.NET MVC project itself (Controllers, Views) I'm looking for the best project structure/organization for my case, especially separating into different assemblies and how dependencies should look like between these layers. Web resources unfortunately don't go into good detail about this. One hint: Currently Repository, Services, IQueryable Fluents etc. work directly against domain model implementation, I don't have an interface definition for them. I considered it unnecessary but maybe this is needed for loose coupling? My Services have an interface (e.g. IOrderService), and my repositories implement IRepository<T>. Appreciate your input on organizing this in a concise manner, and especially what layer should depend on what & assembly organization. Thank you!