Design Patterns in C# (Hardcover)

~ (Author)

Editorial Reviews

Amazon.com Review

Long ago (1995), four object-orientation specialists came out with a book called Design Patterns. In it, the four--whose book became so famous that they became known as the Gang of Four--forwarded a convincing argument that most programming jobs fell into a couple of dozen general categories, and that generic solutions to these programming problems--design patterns--could carry the day a lot of the time. The book remains part of the Holy Writ of object orientation, and indeed if you study it carefully you can save yourself from having to reinvent the wheel every time you set about writing software.

Not long ago (2003), Microsoft came out with a new programming language called C#. It's object oriented, and does lots of nifty stuff with networks. Design Patterns in C# shows you how to implement the 23 "Gang of Four" design patterns in this new language. Steven Metsker's approach is mostly architectural, with lots of object relationship diagrams and relatively little code. He says right up front: "This book is for developers who know C# and want to improve their skills as designers." Among the most valuable parts of his coverage are his comparisons of similar patterns. These clarify, for example, when to use a Builder pattern, as opposed to a Factory or Abstract Factory. The approach helps you become a good C# architect. --David Wall

Topics covered: How to implement the 23 classic Gamma-Helm-Johnson-Vlissides design patterns in C#. Questions scattered throughout the text help you improve your C# skills while you read about pattern architecture.

Product Description

This book is an application book, rather than a theoretical one. It is written for software practitioners who want to gain a better understanding of the patterns described in the seminal design patterns book by Gamma et al. The book's intent is to give developers the confidence and know-how to apply the original 23 patterns identified in the Gamma book, with all code examples provided in C#. There are a large number of programmers and designers who have "grown up" in the Microsoft environment. Traditionally, this environment has not placed an emphasis on structured approaches to software engineering (such as patterns), but there is a growing sentiment toward applying proven approaches to application development (such as design patterns) in this environment. For this reason, the timing for this new book from patterns expert Steve Metsker is superb.

See all Editorial Reviews

Product Details

• Hardcover: 480 pages
• Publisher: Addison-Wesley Professional (April 25, 2004)
• Language: English
• ISBN-10: 0321126971
• ISBN-13: 978-0321126979
• Product Dimensions: 9.4 x 7.2 x 1.4 inches
• Shipping Weight: 2.2 pounds (View shipping rates and policies)
• Average Customer Review: 3.5 out of 5 stars  See all reviews (31 customer reviews)
• Amazon.com Sales Rank: #297,359 in Books (See Bestsellers in Books)

Customer Reviews

Most Helpful Customer Reviews

38 of 40 people found the following review helpful:

4.0 out of 5 stars Works best in conjunction with GoF Design Patterns, October 13, 2004

By	Jack D. Herrington "engineer and author" (Silicon Valley, CA) - See all my reviews (TOP 500 REVIEWER)    (REAL NAME)

This book reminds me of the 'Numerical Recipes in <x>' books. They were the thin adjunct books that accompanied Numerical Recipes which showed the examples implemented in various languages. The books were no good on their own, you needed Numerical Recipes to understand them. This book has the same problem. It doesn't introduce the patterns from scratch, it assumes that you have read the GoF book and that you can use it as the base source material.

That being said the author puts together, succinctly, with both diagrams and code, C# examples for all of the GoF design patterns. Even though in some cases there is very little code because the patterns have been integrated into the structure of the .NET framework.

I think this book is worth a look for anyone writing C# on a daily basis and who is a patterns fan. It's something you need to evaluate before you buy because, frankly, you may already know most of what you are going to see.

25 of 27 people found the following review helpful:

5.0 out of 5 stars Concise, Readable, and Specific, April 12, 2005

By	Christopher Bennage (Tallahassee, FL USA) - See all my reviews (REAL NAME)

I really liked this book.

My background was in VB6 and classic ASP, until just over two years ago. I was introduced to C# and I've never looked back.
Reading about C# best practices led me into design patterns and that naturally led me to this book. It was the first book I've read on patterns (aside from a few articles online.)

Concise - Metsker doesn't waste my time with unnecessary text (such as lame jokes or repetitive text). If I don't get something the first time, I go back and read it over.

Readable - The information in the book is dense, and there are certainly sections that may be confusing initially. However the book thoughtfully organized, the spacing and layout are comfortable, the author's voice reminiscent of a friendly college professor

Specific - His implementation of patterns take advantage of C# specific features. This is important, and I would not have recognized this without the input of C++ developer.</li>


In addition, this book helped to clarify a number of Object Oriented and Component Oriented concepts (such as delegates, interfaces, and iterators). Likewise, it shed light on the .NET FCL (streams and enumerators)

Regarding the exercises in the book; I was irritated with them at first, however I found that they were really useful for making the concepts stick once I quit being lazy. On the flipside, the book is quite useable even if you skip over them.

The only real negative is the metaphor of the fireworks company. It's not intuitive and it takes a while to sink in.

24 of 26 people found the following review helpful:

3.0 out of 5 stars Could be much better, November 7, 2004

By	Milan Negovan (NY, United States) - See all my reviews (REAL NAME)

Pros

Steven knows what he's talking about. All patterns are nicely organized. I really liked chapter introductions and summaries because they were at times much clearer than chapter content itself. Small typos here and there didn't bother me that much. Overall, the book is proof-read quite well.

Cons

Each chapter presents a number of challenges, or quizzes. They appear intermittently with text and therefore distract you from the discussion each time because their solutions are listed in the back and you have to flip back and forth to follow code.

In a couple of places Steven throws a quiz at you and afterwards presents the subject at hand. Normally, you present material first and then quiz. Doing it the other way around is quite a strange educational technique.

Steven is an author of a number book on Java, and it shows in his C# code. Nothing wrong with Java per se, but c'mon! For example, he refers to the book Concurrent Programming in Java as an excellent resource when discussing multithreaded programming in .NET.

The singleton implementation found in this book is downright wrong! It may lead to deadlocks and is not thread-safe. You can find a more efficient implementation of a singleton with a double-check lock at Microsoft's Patterns and Practices.

Conclusion

The book *is* valuable. I didn't think it was a waste of money. Still, it fails to be the best book on the subject of Design Patterns in C# around.