Customer Reviews

34
2.3 out of 5 stars
C# Design Patterns: A Tutorial
Format: Kindle EditionChange
Price:$43.11
Your rating(Clear)Rate this item


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

59 of 63 people found the following review helpful
on April 16, 2003
Format: Paperback
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 MSFT'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.
33 commentsWas this review helpful to you?YesNoSending feedback...
Thank you for your feedback.
Sorry, we failed to record your vote. Please try again
Report abuse
20 of 22 people found the following review helpful
on December 24, 2002
Format: Paperback
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.
0CommentWas this review helpful to you?YesNoSending feedback...
Thank you for your feedback.
Sorry, we failed to record your vote. Please try again
Report abuse
8 of 9 people found the following review helpful
on August 13, 2004
Format: Paperback
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 $...
0CommentWas this review helpful to you?YesNoSending feedback...
Thank you for your feedback.
Sorry, we failed to record your vote. Please try again
Report abuse
8 of 9 people found the following review helpful
on February 1, 2005
Format: Paperback
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.
0CommentWas this review helpful to you?YesNoSending feedback...
Thank you for your feedback.
Sorry, we failed to record your vote. Please try again
Report abuse
10 of 12 people found the following review helpful
on February 24, 2005
Format: Paperback
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)
0CommentWas this review helpful to you?YesNoSending feedback...
Thank you for your feedback.
Sorry, we failed to record your vote. Please try again
Report abuse
10 of 12 people found the following review helpful
on July 2, 2004
Format: Paperback
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.
0CommentWas this review helpful to you?YesNoSending feedback...
Thank you for your feedback.
Sorry, we failed to record your vote. Please try again
Report abuse
10 of 12 people found the following review helpful
on November 18, 2002
Format: Paperback
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.
0CommentWas this review helpful to you?YesNoSending feedback...
Thank you for your feedback.
Sorry, we failed to record your vote. Please try again
Report abuse
12 of 15 people found the following review helpful
on March 29, 2003
Format: Paperback
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.
0CommentWas this review helpful to you?YesNoSending feedback...
Thank you for your feedback.
Sorry, we failed to record your vote. Please try again
Report abuse
11 of 14 people found the following review helpful
on September 9, 2003
Format: Paperback
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 :)
0CommentWas this review helpful to you?YesNoSending feedback...
Thank you for your feedback.
Sorry, we failed to record your vote. Please try again
Report abuse
8 of 10 people found the following review helpful
on July 14, 2003
Format: PaperbackVerified Purchase
The UML diagrams in the book do not follow the UML specifications. The author shows composition when he should be showing aggregation or association.
The author also shows cycles of composition wich is invalid UML.
Like other reviewers pointed out, proper C# was not used in the code examples. For example, no C# Properties were used anywhere in the book.
0CommentWas this review helpful to you?YesNoSending feedback...
Thank you for your feedback.
Sorry, we failed to record your vote. Please try again
Report abuse
     
 
Customers who viewed this also viewed


 
     

Send us feedback

How can we make Amazon Customer Reviews better for you?
Let us know here.

Your Recently Viewed Items and Featured Recommendations 
 

After viewing product detail pages, look here to find an easy way to navigate back to pages you are interested in.