Rating: 
Summary: It served me well when I ran out of toilet paper.
Review: Absolutely, Positively, the biggest waste I ever spent hard earned money on.I bought it because the bookstore didn't have the GoF book, and I thought "This will do". How wrong I was. The introduction to C# at the start is unecessary. I wasn't looking for an introduction to computer programming, I was looking for a book on the GoF design patterns. Not to mention this has been a straight reprint of the Java edition, complete with source code copied straight over. Very dissappointing. Stay away from this book.
Rating:
Summary: It served me well when I ran out of toilet paper.
Review: Absolutely, Positively, the biggest waste I ever spent hard earned money on. I bought it because the bookstore didn't have the GoF book, and I thought "This will do". How wrong I was. The introduction to C# at the start is unecessary. I wasn't looking for an introduction to computer programming, I was looking for a book on the GoF design patterns. Not to mention this has been a straight reprint of the Java edition, complete with source code copied straight over. Very dissappointing. Stay away from this book.
Rating:
Summary: Don't waste your time
Review: Although many have disparaged this book (and with good reason) I thought I would add some weight. The examples have no real sense of direction, with the author adding in methods that have no clear purpose (or explanation). The patterns are not really explained in theory; I guess the reader is supposed to somehow glean what the "big picture" is. Lastly, the glaring error in the Singleton pattern (a VERY common pattern) is enough to make me shudder. After seeing that, I couldn't trust that the patterns that I don't know were implemented correctly. If you are a novice programmer, I advise you to put the book down and back slowly away from it.
Rating: 
Summary: Examples and codes need improve
Review: As a _tutorial_ reader, I expected more easy to understand examples. For example, examples in Chapter 9 are not very straitforward.
A lot of sample codes failed to use nice C# features.
Good UML illustration. Good screen shots of programs. They are very helpful in quick understanding the intention of a design pattern.
I give a 2 stars, lower than the quality of some Googleable on-line tutorials.
Rating: 
Summary: Decent for a C# novice...
Review: As someone relatively new to OO development, I found this book extremely helpful. While not a model for excellent C# syntax (more like Java conventions, but everything works), it does an excellent job of explaining the patterns contained inside in a way that helped me communicate with very experienced developers without feeling like a total noob. I've found that just knowing what most of design patterns do and how they work is a great way to quickly convey high-level design concepts between developers without a ton of explanation and analysis, and this book does a great job of getting a professional C# developer started in the right direction. If you must have something more academically rigorous, get the GoF book, or buy Fowler's tome. If you want to quickly get started learning and applying patterns (audible groans from Java developers, I'm sure) to your .NET projects, pick up this book.
Rating:
Summary: Waste of money - I wish I hadn't bought this...
Review: Basically a horrible book for the same reasons listed by all the other 1 star ratings. I bought it on a whim whilst browsing in a bookstore - wished I'd read a review or few first.
To echo my major issues with it:
- The book is 363 pages long, the first 96 being a tutorial on C# and OO, so its effectively only 259 pages on design patterns.
- The tutorial pupports to teach you both C# and OO general principles in 96 pages (and some UML as well)? Seriously now...
- The whole book is full of typographical errors, particularly in the code with regards to erroneous spaces (or lack of) - there are inconsistencies everywhere, as well as misspelled words etc. etc.
- Poor and erroneous commenting e.g.: //create a new Arraylist
- Examples are very contrived and often far from real world scenarios. I realise examples have to be somewhat contrived for print publishing, but this goes way too far...
- As others have mentioned, the code seems more like Java than C# a lot of the time.
Given the above, I haven't even bothered to load the CD.
Consequently the only bits of the book that are actually valuable are the bits transcribed and summarised from other people books, most obviously the classic "Design Patterns" be Gamma et. al. Given this you're much better off just referring to the original source material. (Ironically both of these books are published by Addison-Wesley)
Rating: 
Summary: For Intermediate Level C# Programmers
Review: C# Design Patterns demonstrates 23 different design patterns which are very useful in object-oriented programming. As the name of the title implies, this particular books focuses on showing these design patterns in the C# language, much like the author, James Cooper, has previously done for other languages such as Java and Visual Basic. If I had to rate the book overall, I would give it an "average" rating, as the book just doesn't seem to stand out among all the other titles available. The book seems to fit best with a specific audience. People who would benefit the most from this book are intermediate-level C# programmers, who know very little about object oriented design patters. If you are a beginner with C#, this book is not for you. The Basics of C# are covered very quickly in the first 7 chapters, but does not go into detail enough to help novice programmers. In fact, I cannot understand why those chapters are included at all. The materials in those chapters breeze over the C# language too fast for C# beginners, but at the same time, it is far too basic for those who have experience with C#. Beginners would be better suited picking up a introduction to C# book and working with the language for a little while before reading C# Design Patterns. Intermediate C# programmers with little knowledge of object-oriented design patterns will develop a new skill set from reading the book. The everyday usefulness of these design patterns makes a book on the subject a very worthwhile read. If the reader is already familiar with C# than this book is a good choice from them. The code samples presented in the book are well constructed and the accompanying CD provides has provided benefit whenever I wanted to see a full code listing. For certain code listings in the book, I would have liked to see a few more comments. Sometimes, it takes a little while to understand exactly what the author is doing with the code. The screenshots and figures do a very nice job representing the concepts visually. One of the best attributes in this book is the thought questions at the end of the chapter. They really get the reader to think and make sure they understand the concepts before continuing. Having a through understanding of each pattern is crucial as later patterns either build or use patterns which have already been learned. People who have read James Cooper's previous works such as Java Design Patterns or Visual Basic Design Patterns or Design Patterns by Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides really do not have a need for this book. This book covers all of the same material as those other works. I have noticed several typos and minor mistakes throughout the book, which is getting far too common in technology books in general. With that aside, I would recommend this book to anyone who knows a good bit of C# and would like to learn about Design Patterns used in Object Oriented programming. I would also recommend that these people skip the first 7 chapters or quickly skim over them. As for anyone else, I would suggest passing on this title, and getting a book that caters to design principles in a language they are more familiar with.
Rating:
Summary: good book for c# developers
Review: Firstly, this book has a good introduction to the c# language, I am already quite comfortable with c# but I enjoyed skimming through this anyway. As well as the introduction to c# the book provides a good introduction to design patterns and has explanations + examples for 23 different design patterns. This is the first book I have read on design patterns and I am already using these patterns in my work. I do feel that the author is more comfortable with coding in java because none of the code examples seem to use properties, instead the author uses getters and setters which I think not good practice in c#. I recommend this book to any c# developers that don't know about design patterns yet. I obviously wouldn't recommend this book to java or c++ developers because the examples are in c#. The only reason I didn't give this book 5 stars is because the formatting of the code examples is a bit messy, and the author hasn't stuck to c# best practices (using properties).
Rating:
Summary: Pathetic
Review: Having suffered through the book to the end, I feel compelled to say what a pathetic disappointment. From the first few chapters it was amazingly clear that the author not only didn't have a firm grasp of C# but had almost entirely misunderstood .Net as well. Intermixed amongst some pathetically poor examples was a combination of editorial errors, mistakes and outright misinformation...I seriously hope noone who has read this book has taken it as an example of how to code, let alone code one of the GoF patterns in managed code. Even the descriptions of the patterns left much to be desired with even one of the simplest patterns, the Singleton not accurately represented. There is 1 saving grace ... it has a nice title :)
Rating:
Summary: Not Impressed with the C# Clone of Java Design Patterns
Review: How can you publish a book when the examples don't even work on the CD??? This book is the same as the Java version (Java Design Patterns) but transformed with C# code! Maybe that's the reason the examples don't work. Think twice when purchasing a book from your company.
| 
