C# Design Patterns: A Tutorial

Rating:
Summary: Incorrect Tutorial Code
Review: The book is well laid out, but the example code invents .NET API code.

Rating:
Summary: needs editing
Review: the outline is great, and the chapters layout seem at first glance, attractive. Lots of code examples, but there are several typos that pretty much render it worthless: can't spend my time trying to understand something that has doesn't make sense because a typo makes it incomprehensible. Look at the last chapter, "Visitor", and look at the names of the subclasses in the figure: the editor forgot to replace the name of "Shape" with "Triangle".

Rating:
Summary: What planet is this UML and C# from?
Review: 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.

Rating:
Summary: Read Design Patterns Explained instead
Review: This book misses the point of patterns. It explains patterns as if they are solutions to recurring problems. Gee, I thought that's what they are? Well, they are - to some extent. They are more about a way to think. The problem with patterns as design solutions is that they don't help you until it is too late. Design Patterns Explained talks about why patterns are good solutions. You can then use this information on any project.

Rating:
Summary: Read Design Patterns Explained instead
Review: This book misses the point of patterns. It explains patterns as if they are solutions to recurring problems. Gee, I thought that's what they are? Well, they are - to some extent. They are more about a way to think. The problem with patterns as design solutions is that they don't help you until it is too late. Design Patterns Explained talks about why patterns are good solutions. You can then use this information on any project.

Rating:
Summary: Good Introduction to C#
Review: This book offers one of the better introductions to C# that I have come across. There are any number of C# introductions out there, but I have seen only one other book that shows how to do object-oriented programming (OOP) with C#.

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.

Rating:
Summary: I lost the CD and can't use the book again.
Review: This is a great book but after i lost the cd i can't use the book any more.
How can I get the code examples again?
[e-mail]

Rating:
Summary: Disappointment
Review: When I bought this book I wanted to apply design pattern to C#. But James Cooper failed to deliver it. This book is a clone from Java Design Pattern. The author didn't even try to use a feature of C# such as property, foreach loop, etc. eventhough he's aware about it. All coding style is Javaish, but the title of the book is "C# Design Patterns." I understand the goal is to learn Design Patterns but at least the author must adapt the C# coding style and use more feature of C# to be consistent with the title and purpose of the book. As far as Design Pattern goes, I learned from it, but I wish the implementation would be better.