Learn more Shop now Shop now Shop now Shop now Shop now Shop now Learn More Shop now Learn more Click Here Shop Kindle Learn More Shop now Shop now

There was a problem filtering reviews right now. Please try again later.

on 22 January 2011
I've had this book for quite some time now and it definitely deserves a long overdue review. I was looking for something that gave an up to date insight on how real applications are built using some of the most popular and proven patterns. There are too many books around that go head first into one specific way of doing things, and it quickly becomes apparent that you cant apply a lot of the techniques to real world situations. This book is not one of those.

Scott provides an introduction to some popular and common design patterns (at which point you will probably find yourself saying 'oh yeah, i used that in '), how they are categorized and most importantly how to read, understand and apply them. He then moves swiftly on to show how these can be used to piece together a rich layered framework on which to build an application. There are various examples of how the various layers interact with each other, all in a very well explained manner, making it easy to understand for developers at any level.

I made the mistake of taking this book into the office, and it has been the source of many conversations since.

Highly recommended.
0Comment| 9 people found this helpful. Was this review helpful to you?YesNoReport abuse
on 10 January 2011
I bought this book in the hope that it would teach me design patterns. I realised after reading the first few chapters that it was mostly over my head. If you don't have a very solid background in OO design, and a reasonable idea of design patterns, then don't read this book - yet.

This is not a criticism of the book, it's a warning to those (like me) who might expect it to do something that, in my opinion at least, it does not do.

I went away and read Head First Design Patterns, which was absolutely superb, and only then came back to read this book. With that background, this book made a lot more sense. It was still heavy reading, but with concentration, I learned a lot from it.

So, why four stars and not five? Well, the first reason is that the book has a lot of mistakes in it. Many of these are simple typos that are not of major consequence, but are annoying. Many are in the UML diagrams, where it looks like they copied and pasted, and forgot to change some of the labels. A few are in the code, although if you read the code carefully (which is the only way you're going to get anything out of this book), you'll probably spot these.

However, a more serious flaw in this book is the lack of clear explanations as to what is going on. One of the selling points in the official blurb is that this book contains lots and lots of code, instead of boring you with theory. Well yes, it does contain an awful amount of code, but a little more theory would have gone a long way to explaining why he did some things the way he did. A lot of the time, he showed a 2-3 page code listing, then by way of explanation, just pulled out selected parts, without really saying why they were there.

I think the main point here is that a high-level overview of his approach would have made the code a lot more understandable.

I don't claim to be any kind of expert in these matters (which is why I bought the book!), but I would still question quite a lot of his approaches. For example, when building an Entity Framework model, he coded all the classes by hand, then generated the model using the Visual Studio wizard, and deleted the classes the wizard created! The whole point of the wizard is that is does all the code generation for you, you don't need to write all your entity classes by hand. I really couldn't see any reason for taking such a long-winded and error-prone approach to something that was designed to be easy.

There are other examples like this. It could be that he had good reason for them, but the lack of overview obscured any reasons.

Without wishing to sound critical (which I'm not, I really did think it was a good book), the large case study in the last few chapters was spoiled by the fact that he used MVC, and so tied himself into something that doesn't allow you to use the methods in other frameworks. He could have picked a less specific UI approach, and it would have been a more useful case study.

Despite these criticisms, I still think it's an excellent book, and one that I shall probably read again.
0Comment| 10 people found this helpful. Was this review helpful to you?YesNoReport abuse
on 4 September 2011
You don't have to be an ASP.net developer to appreaciate this design patterns book. The book is good if you would like to see design patterns applied to real world scenario's, it has enhanced my understanding of design patterns and knowing when to apply the right pattern to a problem scenario.
0Comment| 3 people found this helpful. Was this review helpful to you?YesNoReport abuse
on 12 April 2011
Easy to understand with a clear example case study explaining how different patterns can be applied.

Unlike many books I have read on patterns, this book takes you though different design patterns and then demonstrates how each could be used at different layers of a application. ie. demonstrating where to apply them; not just full theory.
0Comment| 2 people found this helpful. Was this review helpful to you?YesNoReport abuse
on 29 November 2012
Content of this book is outstanding and much needed for my job. For the content i give the book 5/5, this is just for the kindle edition errors.

I own both the actual real life book and the kindle edition. Unfortunately, the Kindle edition has alot of errors in the code examples. I imagine this is due to a less than perfect process of creating the kindle file from the original material but it is very annoying none the less.

It's not a major problem as you realize a piece of code does not look right. But an absolute c# novice may be unable to see these and wonder why the code examples dont work.

Again, the book is fantastic but the code errors in the kindle edition are a little annoying.
0Comment| One person found this helpful. Was this review helpful to you?YesNoReport abuse
on 30 May 2012
As many others have said this book contains good clear introductions to, and examples of the design patterns contained. As anyone who has studied the patterns in theory knows, translating them to the real world is not always as straightforward as one would like and this book does an excellent job of this. It provides lots of good source code, nearly always more than one option e.g. EntityFramework or NHibernate, and good general architecture design.
0Comment| One person found this helpful. Was this review helpful to you?YesNoReport abuse
on 27 May 2011
I have owned this product for two days and can see that the content is well structured with numerous code examples to see how the design patterns may be applied in real-life.

However, I have two problems with this product:

1) The book is not indexed correctly. According to the index, a UML representation of the Strategy Pattern can be found on p.114. Um, try p.116!! Apprently the MVC pattern can be found on p.344-345... Perhaps not. It's actually from p.348 onwards. I know this is a petty thing to complain about, but I expect a book's index to reference content correctly as a bare minimum and it gets annoying when you want to find something quickly!

2) There are typos and grammatical mistakes which can become annoying at times.

That said, these are the only two problems I have with the book and I'm sure you'll be happy with your purchase if you can see past them.
0Comment| 3 people found this helpful. Was this review helpful to you?YesNoReport abuse
on 16 March 2015
Exactly what I was looking for. Cannot recommend this book enough
0Comment| One person found this helpful. Was this review helpful to you?YesNoReport abuse
on 30 August 2014
Good trxt
0Comment| One person found this helpful. Was this review helpful to you?YesNoReport abuse
on 28 February 2014
Facts first, the book consists of three parts. Part 1 is a theoretical introduction to design patterns with a quick example in C#. The second part shows how to apply different patterns to different application layers and the 3rd part is a case study demonstrating an online eshop. The good news is the case study works as promised. I am not so sure about the rest, though.

There is nothing fascinating about the first part, just stuff one can find in any related textbook. Actually, I am wondering if anyone is capable of memorizing the various pattern names, categories and principles listed one after another with short descriptions. The quick example presented is the first worrying sign about what's next.

What is next, is an unnecessary waterfall of separating your application to what practically proves to be a chaotic mess of layers. With the exception of the data access layer (where the well established repository pattern shines) and maybe some parts of the presentation layer everything else is a highly complex alchemy of mercilessly separating everything just to prove it can be done. Of course, all the parts have to communicate somehow and here's where the real trick begins. Pattern after pattern intermixed in poorly explained code snippets that are so difficult to follow in logic and apply in practice you will feel your eyes burning sooner or later. If your are lucky and insistent enough, you may have one or two fairly working examples completed but if you stop and think about it for a moment or two then the conclusion is definitely: too much ado about nothing.

Please, don't let me be misunderstood. I've designed and built a middle size web project based on this book. The above criticism stems out of the fact the final product was so difficult to document and maintain I could hardly focus on the business logic. In other words, this book is an excellent way to prove OOP does not live up to the expectations as suspected by many software developers out there.
0Comment|Was this review helpful to you?YesNoReport abuse

Sponsored Links

  (What is this?)