In an effort to continually improve as a developer, one of the things I do is read lots of books. Recently I read ASP.NET MVC in Action by Jeffrey Palermo, Ben Scheirman, and Jimmy Bogard. In short, I consider this a "must read" for anyone who is serious about developing with the ASP.NET MVC framework.
I've heard some people say that this should not be your first MVC book because it is more advanced than other MVC books available. While I can understand that logic to a degree, I think it would be more accurate to say that if you're literally brand new to MVC, this might not be the best "introductory" book. However, if I could only own one book on MVC, this book would be it. There are two common themes from this book that I really enjoyed. First, the authors base their content on "real world" concepts rather than just explaining every topic in a mechanical way. This gives a great real world context throughout the book. Secondly, the authors are not afraid to be "opinionated" in their recommended best practices for the MVC framework. These are aspects that are lacking in many technical books.
The book starts out with a nice introduction to MVC (and it's not too advanced to follow in the least). One of the things I really liked about this first chapter is that it spent some time discussing the history of web development which gave great context to where and how ASP.NET MVC fits into the discussion. This included many of the reasons as to why we have the MVC framework to begin with. The very next chapter dives into the Model of MVC and does a great job explaining the differences between domain models and presentation or view models. Philosophically, I really agree with their concepts around view models and I have referenced some of them before on this blog. Understanding these view model concepts is essential to building mature MVC applications.
The books then dives into Controllers. The aspect I enjoyed most about this was the emphasis on unit testing. This included mocking and best practices for dependencies. The Controllers chapter ended with a discussion of action filters which was decent but I would have liked if the discussion of action filters had been expanded a little. The Views chapter provided great content covering validation, custom html helpers, partial views, and more. I didn't find the Views chapter to be very advanced at all – rather, it provided a solid foundation for the type of information developers should know when building views.
I really appreciated the chapter on Routing. It discussed designing the routing topology of your application up front which is often overlooked. It also discussed REST best practices. The examples of Routing constraints were one of the strongest parts of the chapter and they are an area that I've observed is often overlooked in MVC applications. My favorite part of the Routing chapter was unit testing routes with the very cool route testing extensions available in the MvcContrib project which makes unit testing routes trivial. For example, it showed how you can test a route in one simple line of code like this: "~/boiseCodeCamp/edit".ShouldMapTo
Towards the end of the book there was a chapter dedicated to exploring (for the sake of contrasting and understanding historical context) MonoRail and Ruby of Rails. I always find the comparisons between Ruby on Rails and MVC very interesting and that was true in this book as well. However, I didn't find myself as engaged in the MonoRail discussion and I didn't think it added as much to the book as the Ruby on Rails section.
Probably the best chapter in the book was the one dedicated to Best Practices. Once again the authors were not afraid to be opinionated in their recommendations and this was based on "real world" experience with the framework (for which there is no substitute). One example I really liked from this section was the advocating of the RenderAction() method. This method has not been without its share of controversy because there are some "purists" that believe the existence of this method violates the tenets of the MVC framework because this means the view has some "knowledge" of the controllers. However, the authors point out (correctly, in my opinion) that the method allows for a much more elegant implementation in many cases that is a very pragmatic choice that actually leads to better separation of concerns in many instances since the partial gets its own controller.
Learning the mechanics of MVC is important. But even more important is learning best practices and how you can extend the MVC framework to suit your needs when the situation requires it. In my opinion, this is the best book I've read that can help get you to that goal.