I reviewed an ASP.NET Architecture and Design book recently. It was OK. I felt it was a bit thin, and didn't cover topics beyond beginner level. Then I got sent a review copy of another book: Professional Enterprise .NET. Having read it, this is the book that the previous book should want to be when it grows up.
Professional Enterprise .NET (Wiley Publishing ISBN 978-0-470-44761-1, 474pp) is written by Jon Arking and Scott Millett. It is intended (quoting the authors) "to serve as an introduction to some of the more popular software patterns and methodologies... for those with some background in Microsoft application development". It is especially geared towards those with some ASP.NET with C# experience. In other words, this book has been written for those people who have reached the point where they now understand why SqlDataSource controls are not used by serious developers. They have a basic understanding of OOP techniques, and are now looking to apply those in a meaningful way so that they can start to realise the promise that OOP holds. They probably don't fully understand how that might be realised yet. These people have possibly looked at ASP.NET MVC, and have now been exposed to a slew of new terms like TDD, Domain Driven Design, IoC, Separation of Concerns etc (or even brushed up against them previously), and want to learn more about how they can be used to make life easier as a serious, developing professional .NET programmer.
Enterprise Development can seem like rocket science. It is surrounded in a language and mystique that outsiders can find daunting - even impenetrable. Chapter 1 of this book does a very good job of breaking through all of that, and lays out the basic principals on which an Enterprise Development approach is founded. Chapter 2 builds on this with a high level discussion of the tools of the Enterpise Developer's trade, illustrated with good clear code samples. Chapter 3 takes a much more in depth look at the whole concept of what "Separation Of Concerns" really means in the context of part of an E-commerce application, and progressively refactors code samples to illustrate points beautifully. The chapter finishes with an extremely thorough and clear discussion on Dependency Injection.
Moving on, Test Driven Development principals are covered in Chapter 4, together with an introduction on using NUnit. Mocking is also covered, with a number of code samples that make use of Rhino Mocks. Chapter 5 is a particular highlight. It discusses Inversion of Control, and completely removes all the mystique that might surround this topic by showing the reader how to write their own (very basic) IoC container. The result won't compete with StructureMap or Unity, but it will help the reader to understand very quickly what these tools are all about. StructureMap is then examined by example. Prior to all of that, alternative methods to decouple dependencies are discussed.
Chapter 6 covers the concept of middleware, and examines distributed system oriented design patterns with a brief look at a WCF service. This is built on quite a bit in Chapter 7, which looks at Domain Driven Design principals in a fair bit of detail, and uses it as a basis for building a piece of middleware. Various ORMs are discussed in Chapter 8, and nHibernate is demonstrated as it is used to refit the application that was started in the previous chapter. The next 3 chapters look at UI matters, and take a good look at the MVC and MVP patterns. The book is then wrapped up with a concluding chapter and an appendix featuring a very brief C# language primer.
This book is extremely well structured, and covers each of its topics in just the right amount of depth, I felt. It's not lightweight by any means. But it isn't a heavyweight academic text book either. I know of Scott Millett. He's quite active around the Architecture sub forum at the asp.net forums. I don't know of Jon Arking, but judging by the style of the book, it's clear that he, like Scott, have a very good understanding of their audience. The book is pitched almost just right at the target it is aimed at. Some of the areas that it covers can be quite contentious, in that there are people around who will claim you are "not doing it properly" unless you strictly follow certain rules. The authors are very careful to point out that they see their role as illustrators of the principles behind approaches, rather than advocators of rigid protocols.
The code samples in this books are easily digestable and well explained. They are not over fussy, and therefore don't obscure the points that they are intended to illustrate. They relate to everyday applications, not arcane industrial processes or cryptographic services that I have been subjected to by some books. The majority of them are ASP.NET samples, but that shouldn't stop WPF or WinForms developers getting a lot out of this book.
I thoroughly enjoyed reading this book, and my copy is a little battered as it has travelled around on trains and in cars with me. I found that any spare moments I had, I filled with getting another section in. If you recognise yourself in the description of the kind of developer this book is intended for, I really recommend that you get youself a copy of it.