Professional Enterprise .NET (Wrox Programmer to Programmer)

• #8 in Best Ruby Books

12 Reviews

Sort by: Most Helpful ▲ Date Rating

Ok I admit it, I buy too many development books. Most of these I never get around to reading properly. Most of that is my fault. Some of the time I'm put off by dry academic type text that doesn't engage with reader. It must by hard too, right? to produce a book covering topics that are far from exciting whilst still making it enjoyable to read.

So it comes as a pleasant, scratch that, 'fantastic' surprise to read this book that manages to convey a vast amount of information on a broad range of key design patterns and methodologies, like TDD, Inversion of control, Dependency Injection, Entity Frameworks and MVP/MVC and yet still remain a joy to read. I own and have part read books on similar subjects from the most established of authors, the likes of Martin Fowler and Bob Martin. While there is no denying these authors have a wealth of knowledge (having developed many of these patterns and methodologies), it's Professional Enterprise .Net that manages to cut past the waffle and terse examples and provide me with the key information I require.

Highlights for me are the topics on TDD and Refactoring, Inversion of Control and Dependency Injection, Business Logic layer patterns (Active Record & Domain Model patterns) and Data Access Layers including ORM. The examples given lead from the simple solution to the most complete and preferred solution. Each chapter is concise enough to be read through again for reference and is a great book to keep at hand when developing.

Minor quibbles I have are the inclusion of the C# primer in the appendix, I feel this has been used to pad out the book. The book is short for this sort of subject (at around 470ish pages), but I count that as a positive. Also I'd like to see a few more common patterns and practices included and given the same treatment relating to examples are guidance on when to use (maybe we need a 2nd book).

I thoroughly recommended this book, don't be put off by the 'Enterprise' in the title, this book is not dry and should be on any developers bookshelf who wants to improve and advance their code.

The book starts off with an interesting discussion about Enterprise development, what it is, and why it's important. It briefly introduces you to the five key areas of enterprise system development: Reliability, Flexibility, Separation of Concerns, Reusability and Maintainability. These topics are discussed in detail in the remainder of the book.

Chapter 2 introduces you to "enterprise code" and shows you how to design loosely coupled classes (by programming against interfaces instead of concrete classes). This in turn prepares your design for Unit Testing and Inversion of Control, two of the main themes of the book.

In the section The New Code - Changing the Way you Build things start to get more concrete. You see how to change an existing design with many dependencies and tightly coupled classes and refactor it into a more flexible design using interfaces and smart constructors that accept other interface types that are used internally. This manual form of dependency injection lays a nice foundation for Chapter 5 that deals with Inversion of Control / Dependency Injection. But first chapter 4 teaches you how to deploy Test Driven Development in your development strategy. It's an excellent chapter that shows you many best practices for TDD, shows how to use third party tools for TDD (NUnit in particular and a plugin to run NUnit from within Visual Studio), how to design for testability and how to use the many refactoring options that are available inside Visual Studio or through external, commercial tools.

If you're new to Unit Testing and TDD, this chapter may be a bit overwhelming at first, and you may want to read it twice. You're also advised to follow along with all the chapter's code in Visual Studio as I know from experience that actually seeing code run can greatly improve your understanding of it. The only problem I had with this chapter was with mocking. The authors do a great job at explaining how to use mocking to make testing easier, quicker and more reliable by abstracting away a lot of behavior in dummy (mock) classes. However, if you're new to this, you may take this too far and mock everything which in the end means you're testing nothing but your mock classes. It would have been nice if the authors had dug a little deeper in the decision process of what to mock and when, and how to combine unit testing with mocks on the one hand with integration tests using concrete classes on the other hand. While it's nice and useful to mock a lot of your code, there is a time where you really need tests that access your database. You need a way to ensure your database is accessible, your tables are setup as expected and your stored procedures align with your own code and the assumptions you have about them. You can't do this with Unit Testing alone as it would unnecessarily slow down your tests. Integration testing is very important, especially in Enterprise type of applications. More attention to integration testing and how to separate them from your unit tests would have made this chapter even more useful.

Chapter 5 shows you the Inversion of Control, or Dependency Injection principles. Building on the stuff you learned in earlier chapters, you see how to implement IoC using a number of different techniques, including an open source project called Structuremap.

Chapters 6 and 7 deal with middleware. You'll learn more about tiered designs, Service Oriented Architectures and WCF. You'll also find a discussion of a number of "persistence patterns", including Transaction Script, Active Record and the Domain Model pattern. While these two chapters contain a lot of useful information, I don't think two chapters are enough for this topic. In my opinion, this middleware layer is at the heart of your enterprise design. It's here where you make decisions that influence the design and flexibility of your application. I would have loved to see topics like Domain Driven Development and the design principles behind it in much more detail.

In Chapter 8 you learn a lot about data access layers and see frameworks such as LINQ to SQL, Entities Framework and NHybernate at work. You get an excellent introduction to each of these technologies, allowing you to compare them and make up your own mind about these frameworks. Again, I would have loved to see some more depth. It would have been nice to see a real Enterprise example of, say, the repository pattern as a layer on top of EF. Many examples show you how to use small, focused repositories often targeting a single entity. However, in practice I often find that having a single repository spanning multiple entities is a lot easier to work with. The book could have helped you with these design decisions by providing and describing a more detailed implementation of repositories using EF or NHybernate in an Enterprise application.

Chapters 9, 10 and 11 introduce you to the User Interface and to patterns such as MVP and MVC; two separate design patterns to separate the front end of your application from the model and your logic. Each topic only gets a single chapter, so you'll probably want to look at other books (such as Professional ASP.NET MVC 1.0 and Pro ASP.NET MVC Framework) as well if you want to dig real deep into these technologies. I still haven't made up my mind if I like the inclusion of both patterns. Clearly, it's great to see both discussed so you can choose a pattern that best suits your needs and development style. However, the two topics are competing for space which inevitably leads to less detail on each topic.

The last chapter in the book serves as a short summary and overview of what you learned throughout the book.

All in all, I think that Professional Enterprise .NET is well worth reading. Whether you're an intermediate developer looking to learn more about design, or a seasoned software designer looking for tips and ideas to improve your own designs (or maybe just looking for a confirmation of your own design decisions), you'll find valuable information in this book. I especially like the chapters on Unit Testing / TDD and Inversion of Control. I also liked the many pointers to open source applications (Structuremap, NHybernate, NUnit and more) and the instructions on acquiring and using them.

I give the book 4,5 stars out of 5. I would have given it 5 stars if it had dug deeper into integration tests and had given more Enterprise examples of repositories on top of your persistence framework.

Reading this book is like solving a puzzle. Its fun because the author's style is fluent. The ideas build a simple yet complete foundation for developing .NET enterprise applications. A outstanding book to foster developer and team lead discussions.

There are high level descriptions, clear explanations of what we're trying to do, and concise examples of code implementing the ideas. Its so well laid out it seems like magic.

I think its a rare combination to find a book with as much technical detail, yet its written and edited like a pro!

I highly recommend you check it out!

This is not a beginners book. As the authors say in the first part of Chapter 2, you should have a moderate-to-advanced exposure to C# which is Microsoft's preferred object-oriented language for the ET.NET platform. There is a C#.NET primer in Appendix A. But this 30 or so pages isn't enough to make you a moderate-to-advanced C# programmer. If you are at that level of a C# programmer, this book will teach you any number of tools, tricks, and neat little programming procedures.

Beyond knowing the programming language, this book is much more about what you do with that programming language. It's about the philosophy of writing code that fits into a large company environment. You wouldn't expect to run a company the size of General Motors using Microsoft Access. Nor should you expect that the complex environment in which large enterprises operate should be able to get by with a program that someone designed in an afternoon.

The coding aspects of this book expose you to a whole range of development tools and concepts that have unfamiliar TLA's (that's three letter acronyms) like MVC, MVP, TDD. To the Microsoft professional who is moving upscale to the enterprise level, this book presents the concepts that you'll need to know. It isn't light reading, but it does expose you to what's happening at the forefront of enterprise architecture.

I've been a developer for over ten years and have had the fortunate and unfortunate experience to read books that with quality ranging from excellent to the horrible/errata prone.

There is nothing more frustrating than reading complex topics that are poorly written. This book sets an excellent standard.

From the very beginning, the subject of Enterprise is wonderfully introduced and leads us to concrete examples of design patterns.

Each chapter is writted just as rich covering class emancipation, TDD, middleware, data layer, front end, MVP, MVC pattern.

This book is great for those new to Enterprise development but a solid understanding of C # will make it easier/quicker to comprehend. The C # primer supplied at the end comes in handy as a refresher.

My only wish is that all the examples were part of one project but then again, it's not a step-by-step book. I give this book 5 stars.

I own Dino Esposito's Architecting Applications for the Enterprise and Patterns of Enterprise Application Architecture by Martin Fowler and found this book to be a great companion in that it takes the idea's of Dino and Fowler and shows you how to implement them using open source and MS frameworks such as NHibernate, NUnit, Entity Framework and LinqToSQL. If you are looking for a more practical example driven book on enterprise patterns and practices then this may be for you, I would strongly suggest getting the Fowler book as well as it goes into more detail and covers many more enterprise patterns.

I just finished reading this book. I think its an excelent book on software architecture for .NET developers.
The book covers the main topics related to the latest enterprise development methodologies (Test Driven Design, Domain Driven Design, Ioc/DI, ORM, Refactoring, etc).
I found the book to be a very good complement to Microsoft .NET: Architecting Applications for the Enterprise (PRO-Developer). Its structured in a similar way and covers every layer of an enterprise application (Bussines Layer, Data Access Layer, Service Layer and User Interface), and the main patterns of each layer with a lot of code samples which help in understanding them.
Other technologies and patterns that the book covers are: MVC, MVP, Monorail, LinqToSQL, Entity Framework and NHibernate.

I strongly recommend this book as an excelent reference of current .NET enterprise methodologies.

As a developer who uses Microsoft technologies to build applications I have noticed that there is a movement from Microsoft to promote enterprise architecture and open source tools. As a developer I've bumped into phrases such as DDD, TDD, ORM, and Design Patterns but was not truly introduced to the subject until reading Professional Enterprise .NET. I am currently at the half way point in the book and have already learned DDD, TDD, ORM and Design Patterns with example code on each subject.

Table of Contents
Part I: Introduction to Practical Enterprise Development
Chapter 1: What is Enterprise Design?
Chapter 2: The Enterprise Code
Part II: The New Code - Changing the Way You Build
Chapter 3: Emancipate Your Classes
Chapter 4: Test Driven Development
Chapter 5: Make It Simple Again - Inversion of Control
Part III: Enterprise Design Patterns
Chapter 6: Getting to the Middle of Things
Chapter 7: Writing Your Own Middleware
Chapter 8: "Mining" Your Own Business
Chapter 9: Organizing Your Front End
Chapter 10: Model-View-Presenter
Chapter 11: The Model-View-Controller Pattern
Chapter 12: Putting It All Together
Appendix A: C# .NET Primer

This is a great book which teaches you the current enterprise development techniques which are used to build on the tenets of good enterprise systems. I highly recommend this book for any developer who comes from a Microsoft/RAD background.

I must say one of the best book I have read on Enterprise Design and Code. The author did very well in explaining how to write flexible, extensible code. If you are a mid level .NET developer and you are curious enough to think about more flexible, testable and extensible applications, you will definitely love this book.

This book covers some of the very exciting topics such as Separation of Concerns, Flexibility, Reusability, Unit Testing, Test Driven Development, Inversion of Control, Domain-Driven, Data access layer, Model-View Presenter, Model-View-Controller. Although it may sounds dry but the author did a great job in keeping me stick to the book. After so many time, this was the book which kept me reading it until i finished it.

The book started with the discussion on What is Enterprise Architecture and Development? Then with an example of Mortgage Loan sample application, the author have applied above mention topics and concepts.

You can also download code of this book from codeplex site.

All in all, I think that it's worth investing time and money on this book and it's really a comprehensive guide to the latest enterprise development patterns and methodologies that will make your code cleaner and maintainable.

The first chapter of this book was basically an attack on Microsoft developers and their poor development habits (due to RAD). However, I was not offended; on the contrary, I was shocked that someone finally pointed these facts out. The authors made a statement, "...built applications for automation" which describes the typical MS developer's methodology. I agree with the entire observation. It's just a shame that most MS developers wont see this book because they are the ones who think they don't need it.

The rest of the book was a great tour through the enterprise patterns and how to implement them. Unfortunately, the book did not provide anything that I haven't already read in about 20 other books; The difference with this book is that the authors do a great job of getting you to think about why you should consider the enterprise patterns and way of life. they cover both small and large project types and do not discriminate against either one which was refreshing.

I was disappointed though about the shear number of grammatical errors in the first few chapters and more so later on. Even worse were the code samples in the Middleware chapters. Following the code right from the book is not a good idea. There were entire methods left out (by mistake, not on purpose) and errors in the code that look as if there was a copy/paste gone wrong.

I don't understand why the authors would include intro sections to Linq to Sql, Entity Framework and NHibernate. I felt it was out of place and unnecessary to accomplish the goal of the chapter. My guess is that it is an attempt to get the reader to open up to new technologies? I do like the fact that the chapter focuses more on NHibernate than Linq to SQL and EF, even though I don't use it.

Overall this was a great read and I recommend that any .NET developer read it for the sake of others who need to look at your code ;)

This book answered many of my questions related to architecture. I love how it explains the relationship between the data layer and the business logic layer using a loosely coupled design. With that being said, I do have a complaint. The book doesn't explain very well the relationship between the what they call the font end layer (presentation) and the business logic layer. The book talks about patterns on the front end like MVC (model view controller) and MVP (model view presenter), but does not give any real examples on how would use them with a multi-tiered design. Overall, this book is very valuable to any developer that wants to move to the next level beyond learning the C# language.

I was skeptical when I bought this book, I read a lot of technology book and for the most part they are only worth two or three chapters or there just a rehash of online documentation. Some are billed at the professional level and spend chapter after chapter teaching the reader how to program. Others provide you with examples that are worthless. Not this book. I have been developing software for over 30 years. I have taught software at the college level. If you really want to know how to develop world-class software this book is for you.