C# Design Patterns: A Tutorial [Paperback]

James W. Cooper (Author)

Book Description

Publication Date: September 27, 2002 | ISBN-10: 0201844532 | ISBN-13: 978-0201844535 | Edition: 1St Edition

This is a practical book that explains how to write C# programs using some of the most common design patterns. With the release of C# and Visual Studio .NET, there is a new interest in the Microsoft development community in some of the OO world's key tools, such as UML and Design Patterns, which they had neglected before. The book covers every pattern identified in Gamma et al's Design Patterns which can be executed in C#. For each pattern, it starts with a brief verbal description, and then builds simple example programs. Each of these examples is a visual program that can be run and examined to make the pattern as concrete a concept as possible. All of the examples will be on the companion CD. The emphasis is on the practical ways to use these patterns to ease the developer's day to day work. This book should be well timed for the growing number of developers who have learned the basics of C#, and now want information on how to get the most out of C# in their real-world application development.

Editorial Reviews

From the Back Cover

Design patterns are elegant, adaptable, and reusable solutions to everyday software development problems. Programmers use design patterns to organize objects in programs, making them easier to write and modify. C# Design Patterns: A Tutorial is a practical guide to writing C# programs using the most common patterns.

This tutorial begins with clear and concise introductions to C#, object-oriented programming and inheritance, and UML diagrams. Each chapter that follows describes one of twenty-three design patterns, recommends when to use it, and explains the impact that it will have on the larger design. The use of every pattern is demonstrated with simple example programs. These programs are illustrated with screen shots and UML diagrams displaying how the classes interact. Each of these programs is available on the companion CD-ROM and can be run, examined, edited, and applied.

Design patterns will have an immediate impact on your work as you learn the following:

Applying design patterns effectively in your day-to-day programming

Using patterns to create sophisticated, robust C# programs

The interaction of classes as demonstrated by UML diagrams

Advancing your programming skills using design patterns

Design patterns will not only enhance your productivity, but once you see how quickly and easily object-oriented code can be recycled, they will become an everyday part of your C# programming.

0201844532B05232002

About the Author

James W. Cooper is a research staff member in the Advanced Information Retrieval and Analysis Department at the IBM Thomas J. Watson Research Center. He is also a columnist for Java Pro magazine and a reviewer for Visual Basic Programmer's Journal. He has published 14 books, which include Principles of Object-Oriented Programming Using Java 1.1 (Ventana) and The Visual Basic Programmer's Guide to Java (Ventana).

0201844532AB05132002

See all Editorial Reviews

Product Details

• Paperback: 416 pages
• Publisher: Addison-Wesley Professional; 1St Edition edition (September 27, 2002)
• Language: English
• ISBN-10: 0201844532
• ISBN-13: 978-0201844535
• Product Dimensions: 9.3 x 7.4 x 0.8 inches
• Shipping Weight: 1.6 pounds (View shipping rates and policies)
• Average Customer Review: 2.3 out of 5 stars  See all reviews (31 customer reviews)
• Amazon Best Sellers Rank: #1,109,500 in Books (See Top 100 in Books)

More About the Author

Discover books, learn about writers, read author blogs, and more.

Customer Reviews

Most Helpful Customer Reviews

56 of 60 people found the following review helpful:

2.0 out of 5 stars this.Book != worthYourTime, April 16, 2003

By 

wickerman "wickerman" (Seattle, WA United States) - See all my reviews

This review is from: C# Design Patterns: A Tutorial (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 M$'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.

19 of 21 people found the following review helpful:

3.0 out of 5 stars For Intermediate Level C# Programmers, December 23, 2002

By 

James J Edelen IV (Jamison, Pa United States) - See all my reviews

This review is from: C# Design Patterns: A Tutorial (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.

8 of 9 people found the following review helpful:

1.0 out of 5 stars This book is HORRIBLE (Misinformation written all over it), August 13, 2004

By 

J. Cheung (San Francisco, CA) - See all my reviews
(REAL NAME)   

This review is from: C# Design Patterns: A Tutorial (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 $...