- Paperback: 416 pages
- Publisher: Addison-Wesley Professional; 1 edition (September 27, 2002)
- Language: English
- ISBN-10: 0201844532
- ISBN-13: 978-0201844535
- Product Dimensions: 7.3 x 1.1 x 9.1 inches
- Shipping Weight: 1.6 pounds (View shipping rates and policies)
- Average Customer Review: 32 customer reviews
- Amazon Best Sellers Rank: #2,835,175 in Books (See Top 100 in Books)
Enter your mobile number or email address below and we'll send you a link to download the free Kindle App. Then you can start reading Kindle books on your smartphone, tablet, or computer - no Kindle device required.
To get the free app, enter your mobile phone number.
C# Design Patterns: A Tutorial 1st Edition
Use the Amazon App to scan ISBNs and compare prices.
Fulfillment by Amazon (FBA) is a service we offer sellers that lets them store their products in Amazon's fulfillment centers, and we directly pack, ship, and provide customer service for these products. Something we hope you'll especially enjoy: FBA items qualify for FREE Shipping and Amazon Prime.
If you're a seller, Fulfillment by Amazon can help you increase your sales. We invite you to learn more about Fulfillment by Amazon .
The Amazon Book Review
Author interviews, book reviews, editors picks, and more. Read it now
Frequently bought together
Customers who viewed this item also viewed
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:
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.
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).
Top customer reviews
There was a problem filtering reviews right now. Please try again later.
I have bought many wrox books in my time amongst others and with all the others barring Addison-Wesley , I get on the site and download the code. I don't need to know the site because it's all rather obvious and straightforward how to do so and I DON'T need to go through the painful process of registering and searching and becoming frustrated and annoyed.
The samples in this book are far from complete - Sure you can work it all out yourself but if I have to do that then I wouldn't have bothered with a book. I bought the book to speed some things up - If I wanted to figure out samples in the .net framework out on my own - or - just wanted the theory , then the original gang of four book already covered that and this book is a waste of my time and money.
James J Edelen IV ,December 23, 2002 who looks
like the only reviewer in amazon.com
who ever even tried the examples out in the book.
This book is a fast pace intro into the use of OOP.
The best book out in OOD for c# of which only an intermediate
programmer can take advantage of.
The author has indeed taken time to introduce as
much patterns to the reader and his examples do work as
opposed to what others say
OOP addreses one of the real shortcomings of C# and VS.Net--their Visual Basic heritage. Visual Basic was certainly easy to use; slap some controls on a form, add some code to the controls' event handlers, and you had yourself a working program. The problem is, this simplicity encouraged really ugly programs that couldn't be changed or extended. To use a house analogy, you couldn't simply repaint your kitchen. You had to tear it down and build a new one.
That's one of the main reasons why VB developed a reputation as a 'toy' language, and why 'real' programmers turned to Java in droves. It offers much of the simplicity of VB, but it encourages the creation of cohesive, loosely coupled objects that are easily extended, maintained, and reused.
C# has retained almost all of VB's simplicity, with predictable results. C# web sites are full of slapdash apps that whip up a few forms and plug in some code. C# is in real danger of becoming another toy.
And yet, C# offers a rich set of abstaction tools. With these tools, a developer can create real applications, in a fraction of the time required to do it in C++. The same language can be used to build junk, or really elegant applications.
The key to using C# effectively is OOP. The 'Gang of Four' (GoF) design patterns discussed in this book provide proven solutions to common OOP issues. If you understand the GoF patterns, you have a good understanding of OOP. It's that simple. And that's what Cooper sets out to provide.
In the first seven chapters of this book, Cooper does as good a job as I have seen of introducing C# and OOP. If you have no previous experience with OOP, you will probably need another book to get you started. I'd recommend 'Object Design' by Rebecca Wirfs-Brock. If you have been exposed to OOP, but you are not fully conversant with abstraction and its role in your designs, I strongly recommend 'Agile Software Development' by Bob Martin.
Those books will prepare you for Cooper's explanation and demonstration of the 23 GoF patterns. Cooper recommends getting the original GoF 'Design Patterns' book (Gamma et al) to use as a companion reference, and I think that's a good idea. What Cooper does best is describe how to implement the patterns in C#-- how to get from design to working code.
This book has been criticized for the style of its pattern implementations. Some reviewers consider them simple Java ports, and others have criticized the fact that they do not always use all the bells and whistles provided by C#. I agree that the implementations owe a lot to Java, and I might even go so far as to consider them ports.
And that, I think, is one of the book's great strengths. For it results in code that is highly portable between Java and C#. Even if you are married to C#, you will at some point have a client who is just as married to Java. Reusing your C# components is going to be a lot easier if you follow the sort of cross-platform style in this book. And if you are a Java programmer considering C#, it makes this book a great reference for migrating pattern-based solutions from Java to C#.
I have a few quibbles with the book, but these are mainly editorial. There are code listing typos, but apparently no web site with corrections. The UML editor provided on the CD-ROM to read its UML files doesn't seem to read them. And the UML editor is a much weaker editor than several other UML editors on the market. I would not consider it a top-tier product.
Subject to these reservations, I would strongly recommend this book to anyone learning C# and OOP. I wish it had been around a year an a half ago, when I was trying to learn both at the same time.
Also, the code implementation for a number of the patterns just flat out makes no sense. In the Singleton implementation, after the Singleton instance is created and returned on the first client call, on subsequent calls you don't get a reference to the already created instance, it just returns null. What?!??!?
In short, I can't believe this book is still for sale, and more importantly, I can't believe Addison-Wesley published it in the first place. I usually find their tech books to be of fairly good quality. I'm sure I bought this book thinking it would be good to have one that implemented the patterns in C#, but that really is unnecessary. Java is close enough to C# that Head First will make perfect sense to a beginning C# developer. Advanced C# developers should be on the lookout for where modern C# language features (like lambdas) render some of the patterns obsolete. No matter what, this is not a book anyone should try to use in learning about design patterns.