Professional Enterprise .Net

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.

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