C# 3.0 Design Patterns (Paperback)

by Judith Bishop (Author)
Key Phrases: creational patterns, template method, protection proxy, Behavioral Patterns, Structural Patterns, Factory Method (more...)

Editorial Reviews

Product Description
If you want to speed up the development of your .NET applications, you're ready for C# design patterns -- elegant, accepted and proven ways to tackle common programming problems. This practical guide offers you a clear introduction to the classic object-oriented design patterns, and explains how to use the latest features of C# 3.0 to code them. C# Design Patterns draws on new C# 3.0 language and .NET 3.5 framework features to implement the 23 foundational patterns known to working developers. You get plenty of case studies that reveal how each pattern is used in practice, and an insightful comparison of patterns and where they would be best used or combined. This well-organized and illustrated book includes: An explanation of design patterns and why they're used, with tables and guidelines to help you choose one pattern over another Illustrated coverage of each classic Creational, Structural, and Behavioral design pattern, including its representation in UML and the roles of its various players C# 3.0 features introduced by example and summarized in sidebars for easy reference Examples of each pattern at work in a real .NET 3.5 program available for download from O'Reilly and the author's companion web site Quizzes and exercises to test your understanding of the material. With C# 3.0 Design Patterns, you learn to make code correct, extensible and efficient to save time up front and eliminate problems later. If your business relies on efficient application development and quality code, you need C# Design Patterns.

About the Author
Judith Bishop is a computer scientist, in Pretoria South Africa, specializing in the application of programming languages to distributed systems and web-based technologies. She is internationally known as an advocate of new technology. Her books on Java and C# have been published in six languages. She represents South Africa on IFIP TC2 on software and is a chair or member of numerous international conference committees and editorial boards.

Product Details

• Paperback: 314 pages
• Publisher: O'Reilly Media, Inc.; illustrated edition edition (January 11, 2008)
• Language: English
• ISBN-10: 059652773X
• ISBN-13: 978-0596527730
• Product Dimensions: 9 x 7.2 x 0.7 inches
• Shipping Weight: 1.1 pounds (View shipping rates and policies)
• Average Customer Review: 3.2 out of 5 stars See all reviews (20 customer reviews)
• Amazon.com Sales Rank: #50,829 in Books (See Bestsellers in Books)

  Popular in this category: (What's this?)

  #70 in

  Books > Computers & Internet > Programming > Languages & Tools > C#

Customer Reviews

Most Helpful Customer Reviews

10 of 10 people found the following review helpful:

4.0 out of 5 stars Good overview of Design Patterns using C# 3.0 but seems rushed, March 31, 2008

By	Shafik Yaghmour (NY USA) - See all my reviews (REAL NAME)

On one hand I like the book, I feel the layout and presentation of each pattern is well done, concise, yet you can grasp the main point of each pattern. Each pattern is explained, implemented, further examples are given, uses are explained and then each pattern is wrapped up with a series of exercises.

On the other hand, the book has many typos, the exercises are a very mixed bag and sometimes the explanation are incorrect or incomplete and it is hard to understand why the author really did what they did or the full implications. This really is a mar on an otherwise solidly presented book. The errors did make me dig into the details and I did learn more from my digging. So, if you are willing to work around these warts than you will learn something but for a beginner the level of frustration may not be worth it. For example the Observer pattern blog example, which uses events with a dictionary was not explained in enough detail. If you looked, you would have found something along the lines of the MSDN article "How to: Use a Dictionary to Store Event Instances (C# Programming Guide)" but you had to look for it.

This also applies to the C# 3.0 features that are presented in the book, again citing the example above. The Mediator pattern has a sidebar on delegates and events and it explains in a very high level what you need to know to implement events stored in a dictionary but unless you use sources outside the book you will be missing out on a lot.

The exercises are varied, some are excellent and they really force you think about what the pattern is about and sink your teeth into the details. Others just seem like they are there to fill space, others do not seem thought out well enough. For example in the Decorator pattern one of the exercises asks you to decorate System.Console but you can not do it using the methods presented. You can use a wrapper but that is not really decorating, so you are left wondering what the real intent was or even worse did you miss some key point.

So overall, even though the book does have warts, it definitely useful, you will learn about the GOF design patterns and come away with some useful knowledge on C# 3.0 and beyond that. I would suggest using the book with a critical mind, try to pick apart the examples and experiment with them, test the authors claims and find the mistakes. My impression is that this book needed another revision and some sections feel like they were in the process of being revised but the book was shipped before the process was done.

If I could I would give the book 3.5 stars, it is still very useful but the warts are painful and coming from O'Reilly that is disappointing. Some have mentioned the "Head First Design Patterns", also by O'Reilly. I have to say that if you want to learn design patterns from a Java perspective I would probably recommend that book instead.

BTW, A previous reviewer had claimed the Observer pattern example did not work but I did not have any problems getting that example to work.

9 of 9 people found the following review helpful:

5.0 out of 5 stars A Good Presentation of the GOF Patterns in C# 3.0, February 13, 2008

By	T. Anderson (PA USA) - See all my reviews (REAL NAME)

I found this book to be a very good treatment of the GOF patterns. The content is well organized and has a very clean feel to it.

I think there would be 2 primary audiences. One would be those that have study the GOF patterns, but want to see them implemented with the latest C# functionality available. The other would be those that have never before studied the GOF patterns and want to learn about them. I think both audiences should know the C# 3.0 language and syntax before reading this book, or at least be willing to learn C# 3.0 while reading this book.

Although the author claims this is a the book will guide you through the new C# 3.0 language features, they are only really listed. The side bars are enough to send you off looking for the right thing to learn, but you won't learn it with the content in the sidebar. As long as you are willing to go outside the book to learn the new C# 3.0 features, this book will serve to point them out.

Each pattern is broken down into 7 parts- Role, Illustration, Design, Implementation, Example, Use, and Exercises.

I think the author does a great job at communicating the intention of the patterns. She makes good use of graphics and UML diagrams. She also makes you put some thought into the patterns by offering mini quizzes.

The author also has a nice support site which has the code available and a lot of good information about patterns including the UML diagrams from the book. The code is very well organized and is very usable.

All in all I think this is a great C# GOF Patterns book and would recommend it to anyone that wants to learn to implement the GOF patterns with the latest C# language features available.

14 of 16 people found the following review helpful:

5.0 out of 5 stars Nice Treatment of GOF Patterns, February 7, 2008

By	James Holmes "Co-Author 'Windows Developer Po... (South Central Ohio) - See all my reviews (REAL NAME)

This is a good rehash of the Gang of Four patterns, reworked in C# 3.0. The book's fairly concise and most patterns are clearly laid out with a simplistic example to demonstrate the basics of the patterns followed by a more detailed example in a semi-real world implementation.

The articles are nicely done, there are a good set of exercises about each pattern, and there are some good comparisons between similar patterns. As an example, there's a bit comparing the Builder and Abstract Factory which details that a Builder is concerned with how things are built while an Abstract Factory is concerned with what is built.

A couple things bothered me in the book, namely the lack of a clear overall summary of patterns, and an annoying batch of sidebars on fairly basic concepts. While each pattern has a summary of when you would use it, you're forced to dig through the entire book looking at each pattern trying to figure out if it will solve a problem for you. A consolidated list of the uses of each pattern at the start or end of the book would have been a great help. Regarding the sidebars: do I need a patterns book to lay out fundamental concepts like accessibility modifiers or indexers? These detract from the book's main purpose, which isn't to teach C# 3.0, but show how patterns are done in C# 3.0. Sidebars specific to a pattern's C# 3.0 intricacies are OK, but the fundamentals should have been left out.

Those annoyances aside, I found the book to be a good read and a useful addition to my bookshelf.