Reviews for Professional Enterprise.NET (Wrox Programmer to Programmer)

1. Highly recommended

   Rated 5 out of 5 stars, March 12th, 2010

   
   I've been working in the software development arena for a number of years now and have recently been learning about design patterns.
   
   Having read Head First Design patterns, (which I think has a unique and great way of teaching patterns), I still couldn't manage to get the patterns in my code. This book however, has finally allowed me to clearly identify and implement some useful patterns in my code, some I was already using but didn't realise! It offers clear explanations of why and how to organise your code into a clear and testable manor. The book has three distinct sections with a total of 12 chapters and presented in a good logical order.
   
   Part I, an Introduction to Practical Enterprise Development, covers the question why and what enterprise architecture and development is, these chapters cover the concepts of enterprise architecture and development talking about Reliability, Flexibility, Separations of Concerns, reusability and maintainability.
   
   Part II, the New Code -- Changing the Way You Build, shows you how you can write and organise your code to support the concepts discussed in part I. It also offers practical learning covering many key concepts in a logical order, amongst other things you will learn about loose coupling, refactoring, TDD, mocking, abstraction, unit testing and a variety of patterns.
   
   Part III, Enterprise Design Patterns, this was the meat for me, effectively covers various design patterns and tools that can be used. For me, some of the best content is in this section, I especially liked the Model-View-Presenter and Model-View-Controller patterns, this part of the book explains why and when these patterns can be used.
   
   In Summary, I would definitely recommend this book, it's a worthwhile read. It taught me so much about what's available out there and what's being used now in software development and will stay as a hands on reference resource going forward.

2. Practical hands on approach to learning the principles of enterprise development

   Rated 5 out of 5 stars, January 12th, 2010

   Professional Enterprise .NET is structured in a clear and concise manor facilitating ease of use as a quick pick-up reference tool and progressing through the chapters.
   
   This book does a great job of taking all of the mystery out of enterprise development and breaks it down to its foundations that are based around loosely coupled but highly cohesive modules of code.
   
   The practical hands on approach to learning the principles of enterprise development are structured in the form of fully working small applications and one larger sample application.
   
   It covers all of the patterns in the 3 main layers of an enterprise application, namely the Data Access, Business and Presentation Layers.
   
   There is great coverage of open source frameworks such as NHibernate, NUnit, Rhino Mocks and StructureMap as well as MS frameworks like Entity Framework and LinqToSQL. It would have been good to have seen an example of the Castle Windsor Active Record project as this is based upon NHibernate and the Active Record pattern is covered in the book.
   
   This book works as a great companion to Fowlers Patterns of Enterprise Application Architecture book and a great next step book for .NET developers that have a good understanding of the .NET framework but are looking to improve the way they code.
   
   I have recommended this book to colleagues and friends alike that want to program well structured .NET code.
   

3. Simple, clear and concise explanations of advance topics

   Rated 5 out of 5 stars, January 12th, 2010

   A great book that cuts through the usual guff that surrounds the advance topics of .net enterprise application architecture. Standout chapters include a very good explanation of the Dependency Injection Principle via a straight forward refactoring exercise, a nice new spin on the TDD samples that you usually read which shows the end-to-end construction of a noughts and crosses game and a nice demonstration of applying the concepts of Domain Driven Design to a small mortgage application. I would thoroughly recommend to any .net developers looking to move into the world of enterprise patterns, best practices and principles.

4. Great Pragmatic Enterprise .Net Book

   Rated 5 out of 5 stars, December 12th, 2009

   If you've read Fowlers Patterns of Enterprise Architecture or Uncle Bobs Agile Principles, Patterns, and Practices in C# and have found them rather dry then this is the book for you.
   
   The authors do a great job of explaining enterprise patterns, principles and methodologies in a down to earth and pragmatic way. I found the chapters on Test Driven Development, Dependency Injection and Inversion Control the most useful. My only criticism is that the book didn't cover any GoF design patterns, other than that it was really good :0)

5. Highly recommended - Mikesdotnetting

   Rated 5 out of 5 stars, October 12th, 2009

   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.