web api controller in n-layer architecture

Interesting, just answered a similar question...

So I woudn't do it I were you.

Here's just a few disadvatages of the approach from the top of my head:

1. Performance - a redundant HTTP roundtrip in Web MVC project.
2. Separation of concerns - most of the time the functionality provided by API differs greatly form UI for the same project/application. You might want to limit the API to a few methods with a strict contract. In case you want Web API to be a layer between Web MVC and your DAL you will have to expose all functionality you need for UI as well. Also you might want to have different authorization and authentication mechanisms. Very often API exceptions handling is also different as well as input validation.
3. Maintanance - everytime you need to make a change required for UI only you have to make sure it doesn't brake your API clients. Also API versioning is a very important topic and mixing it with most UI changes makes this process even more difficult.

Probably for now you application is not that complex but from the design perspective your solution is much more flexible now than it will be if you decide to put Web API between your UI and DAL layers.

N-Tier applications and multi-layer are not popular among the new wave of developers. Keep in mind, that just because something is not popular, among a group, does not mean that it does not have merit.

Pros of MVC:

• Separation of Concerns
• Unit Testing

Does a multi-layer MVC application using a Web.API have merit:

I know this will be met with some discontent and disagreement. However, my concern is that single purpose application developers are not giving consideration to enterprise development. Enterprise development, load balancing, manageable code maintenance, and true Separation of Concerns are only possible with multi-layer applications that can easily lend themselves to N-tier.

Many developers are operating in environments that demand that they design and implement data structures in SQL, create and maintain models and CRUD functionality, develop controllers and design good looking and friendly views. The MVC model utilizing Entity Framework makes this a manageable task for these small to moderate platform developers.

In the Enterprise, separating the Business and Data Access layers from the User Interface makes real good sense. Right now MVC is a popular and very functional platform for efficient and usable User Interface development. What will be the UI platform in ten years? Separating the UI from the other layers gives more life to the work spent developing the business logic. Not to mention, that it allows for accessing data on multiple platforms today.

Multi-layer MVC using Web.API has these advantages:

• True Separation of Concerns
• Supports Unit Testing
• Makes the Business logic and Data Access logic more scalable and reusable than MVC alone.
• Supports data processes without page refresh. (REST)

CONS: - Does not easily support use of Entity Framework. (Which is not ready for the enterprise yet anyway)

You could have your code as part as your model, and that would even be considered as good separation of concerns since MVC is build for that.

But what my preferred thing to do is keep logic in a Business Layer of it's own. The reason for that is, I think, better separation of concerns. I like using IoC, so there might be different configurations that I route thought different running solutions. Or, I might have another UI/API/Project that uses the same logic layer.

As for the overhead, it has a little overhead, but I think worth the trouble comparing to the actual overhead in code it creates.

I agree with others here, looking into using strongly typed views, the controllers would only create an instance of the viewmodel and send it on to the view. The view model then is the intermediary to the data services layer. I personally create all my entities using EF in a different project just to separate function. The view model can either call EF directly or you can add another layer of pre-canned EF queries which the Viewmodel uses just to populate the view collections. This would look like this:

[View]-[Controller]-[Viewmodel]-[Optional repository and interface to EF]---[EF]

In the interface to EF you would catch all DB errors when trying to get information and post back to the view according to your design.

The beauty of strongly typed views is that they post back and forth from the View and can contain methods which you can call at will. Because they are a pseudo model for the view, they can also have properties specific to the view which may be used at the business layer. I pass view models around quite a bit were warranted. (After all they are just a pointer)...

You can implement business logic/validation/calucations in the actual model/entity classes rather than ApiControllers, otherwise you will end up with so much code in your controller which is not really a good thing.

Also you can use DataAnnotations Attributes to perform your validation which sits outside of your controller. for.e.g. http://msdn.microsoft.com/en-us/library/ee256141(v=vs.100).aspx