I bought the book in high hopes and good faith for a well researched and easy to read text. I was mistaken.

I didn't mind the first 7 chapters being a sort of 'programming overview' and introduction to the concepts used in the book - what I did mind was that it was poorly expressed, often missed key points and was sloppy and felt rushed. For example, in Chapter 4 some of the code (in the 4th edition of the text mind you), went something like this:

if (index > length of array) {
return array[index]
} else {
return special value
}

I am sure I am the only one to see the problem with that.
Then in chapter 7 (I think), they have this gem:

pos = string.trim().indexOf(" ");
if (pos > 0) {
left = string.substring(0, pos).trim();
....
}

Ok, so most of the time this is going to work, but if the string begins with some whitespace? *sigh*

Then when they finally got to the patterns, it still felt rushed, the descriptions were little more than an introduction to the code (as stated already questionable) that implemented the pattern - not much to give you that 'aha' moment they talked about in the introduction, and from what I understand they didn't even explain the Singleton pattern correctly....

It was at this point that I returned the book and bought the original "Design Patterns: Elements of Reusable Object-Oriented Software" - at least I know they know what they are talking about, and so far it has been much better (and cheaper), so now I can relax and actually learn something.

In this book's defence I didn't actually open the CD and try to run the code to see if they had fixed the bugs as written in the text - but if a programming book can't even match discussed code with runnable code, then it's pretty poorly written/maintained in my opinion.

Nuf said.

While reading this book, I found myself wondering what took me so long to get this book. It's not difficult to read, and each of its 22 design patterns is both applicatable for different goals I needed, and easy to implement in my code.
I recommand this book to anyone starting to program C# applications, and/or Buisness logic classes.

It blew my mind, and Improved my C-Sharp skills a lot.
I hope it does the same for you !

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)

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.

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.