Rating: 
Summary: Nearly impossible to finish
Review: I personally found this a poor tutorial on design patterns and C#. The examples the author used were often contrived and reeked of needless complexity. The tutorial on C# was brief, incomplete and unnecessary (leave the task of teaching C# to a book of it's own). The code seemed to be ported from another language instead of being written with C# in mind (for example the use of a getName() method instead of using a Name property). If your looking for a tutorial on design patterns check out Robert Martin's latest book on Agile Software Development. It doesn't use C#, but it covers the classic GOF design patterns (plus a few others), explores XP programming and (in my opinion most importantly) covers principles fundamental to object oriented programming and design.
Rating: 
Summary: Terrible book for beginner or expert
Review: I'm what I would call an advanced C# developer, but have always felt I could use some education in accepted design patterns. I thought this book would be a great start. Boy was I wrong! I second every complaint I've read in these user reviews.
That said, I'd like to add one more to the list: Often there was nothing in the text to explain how exactly the example code exemplified the pattern being discussed! This was maddening to me--you get some bad code, then an unnecessary line-by-line description of how the bad code works, but you're no closer to understanding the proper application of the design pattern.
Rating:
Summary: The worst book I ever read
Review: It is the worst book I ever read. Subject matter is not explained properly. Examples are complex and lengthy. Don't buy this book.
Rating: 
Summary: Good Introduction
Review: It's a good introduction book to the use of 23 major design patterns in C#. As someone new to this area, I found the book very easy to follow aided by the very practical examples. The author did a good job explaining these patterns in very plain language.
The first part of the book covers the mere basics of Visual Studio .NET, the C# language, object programming concepts and UML diagrams. I feel this section is not necessary since there are abundant books available. I'd also like to see in future editions a heavy-duty application designed throughout the book using most, if not all of the 23 patterns. -- Review by Timothy D.
Rating: 
Summary: Design Patterns for C#
Review: Just as the title promises, an application of the design patterns described in _Design Patterns_ (Gamma et al) to a C#/.NET programming environment. Generous use of examples, and some good bits of insight regarding the C#/.NET environment where appropriate. Paired with a good detailed C# book, _C# Design Patterns_ is a good aid in migrating Design Patterns believers to C#/.NET. Alternatively, this book is also a good introduction to Design Patterns for beginning/intermediate C# folks.
Rating:
Summary: lahtedah
Review: not a bad book but...your editors should have caught the problem in chapter 9. The use of undefined terms is always a curse to any book. The terms "heat" and "seeded" are not defined. Maybe the author thought it was cute to use some terms from what his children were participating in. This set of terms slows down the reading process because the reader has to second guess the author. The author seems to be trying to teach but this chapter is ill-advised. I call this "lahtedah". The author listed Hawaii as one of his cities page xx. This is more "lahtedah". Too much name dropping and kissing the art of the famous people associated with his subject. The GOF wrote a book that was very poorly written but nevertheless led many to worship the book. The world of sheep...know what to kiss and when indeed. The best authors are Stephen Prata and Ivor Horton who write 100% teaching and 0% lahtedah.
Rating:
Summary: Very solid read
Review: Personally, I found this book very easy to read - and I actually appreciate the fact that some time is spent on C# fundamentals prior to diving into the patterns. If you're already a C# master, skip the intro and go right to the patterns. But just about everyone can use a refresher on language fundamentals so even though I'm pretty familiar with C#, I still found it a valuable part of the book.
Rating:
Summary: this.Book != worthYourTime
Review: Some of the other reviewers have already touched upon my major complaints: 1. If you need to read the first part of the book (Chapters 1-7) you probably aren't ready for design patterns as a concept. This eliminates almost 100 pages from the book's 363 pages. 2. The code samples aren't C#, they're Java. I'm not a .NET evangelist or anything like that - it's just that if I want a Java book, I'll buy a Java book. A book about C# & .NET should at least make an attempt to follow M$'s 'best practices' regarding coding style. 3. The organization of the book feels sloppy and haphazard. The best example of this: what is a so-short-as-to-be-almost-useless chapter "UML Diagrams" doing wedged in between "Inheritance" and "Arrays, Files, and Exceptions in C#"? The author totally glosses over UML (which might have been helpful for the uninitiated), providing little to no practical information, and seems to be making a sales pitch for WithClass, the software used to produce the UML diagrams in the book. All in all, I was pretty disappointed. My recurring sense was that the author couldn't tell if he was writing a book targeting intermediate or beginning programmers, with the end result being a book that really won't do either a whole lot of good. The sole redeeming feature of the book is that it does provide a quick and dirty overview to the 23 design patterns described in the seminal GoF. For someone entirely new to design patterns as a concept this might prove helpful. However, even this could have been achieved in fewer pages for a lot less money with better code. And as a C# reference, while the author does make a point of stating that this isn't intended to be a C# reference, he goes on to state that you "...will find, however, that this is a fairly useful tutorial in object-oriented programming in C# and provides a good overview of how to program in C#." (pg. 8) To call this stretching the truth would be kind; I returned this book the day after I bought it.
Rating:
Summary: This book is HORRIBLE (Misinformation written all over it)
Review: The beginning intro the C# is absolutely POINTLESS. The author should have spent more time on providing better examples and discussions of his design patterns.
Pg 110: "In both cases our events classes contain an instance of the base Events class, which we use to read in the data files."
Ok, the base Events class he is talking about has been declared as an Abstract class... and he is telling us that our derived classes contain instances of the base Events class? What is he trying to do, provide misinformation? You can't instantiate or have instances of Abstract classes!
This is an utter waste of $...
Rating:
Summary: pattern intro for c#
Review: the best description on this book is given by
James J Edelen IV ,December 23, 2002 who looks
like the only reviewer in amazon.com
who ever even tried the examples out in the book.
This book is a fast pace intro into the use of OOP.
The best book out in OOD for c# of which only an intermediate
programmer can take advantage of.
The author has indeed taken time to introduce as
much patterns to the reader and his examples do work as
opposed to what others say
well done.
| 
