Product Description

If you want to speed up the development process on your .NET applications, you're ready to take advantage of C# design patterns - elegant and repeatable solutions to common programming problems that enjoy wide acceptance in the industry. This book is a clear introduction and reference to this difficult subject, with an insightful comparison of patterns and where they would be best used or combined. "C# 3.0 Design Patterns" offers you a fresh approach. While some sources present C# design patterns converted from C++ and Java code, this book gives you patterns using C# 3.0 language features and a bold use of C# libraries, along with plenty of case studies to illustrate how each of the 23 patterns is used in practice. You get less of the why and more of the how, when and what in this concise and practical guide, with program examples that make sense."C# 3.0 Design Patterns" includes: an introduction that explains what design patterns are, why they're used, and how to choose one pattern over another; extensive coverage of the classic creational, structural, and behavioral design patterns; new design patterns in popular areas such as parallel programming, security and web design; interesting real-world examples that work well in the design pattern framework; case studies on patterns in mobile computing and applications in software architecture; examples embedded in real programs running on the companion web site; and, tables and guidelines for the choice of patterns. With the improved features of C# 3.0, design patterns are an efficient and clever way to overcome hurdles in software development with proven, tested templates - if you know how to use them. This well-organized and illustrated book gives you an excellent head start on these effective tools.

Product Details

• Amazon Sales Rank: #96187 in Books
• Published on: 2008-01-11
• Original language: English
• Number of items: 1
• Binding: Paperback
• 290 pages

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.

Customer Reviews

Let down by poor examples
I'm an IT professional currently working with C# and the .NET Framework and whose previous knowledge of Design Patterns was gained mostly from the excellent Head First Design Patterns book.

So it was with eager anticipation that I pre-ordered this book with a view to enhancing my Design Pattern knowledge while simultaneously getting acquainted with the newer (and possible lesser used) features of the C# 3.0 language.

In general, the concept of the book is sound and well structured. Each design pattern is presented by its Role (high level description), Illustration (some everyday example of how the pattern is implemented), Design (UML diagram), Example (theoretical code, practical code), Use (scenarios where the pattern may be considered) and Exercises (enhancements to Examples). New or unusual C# language features used in each pattern example code are presented in summary in sidebars when required - nice feature.

Where I feel the book does let itself down is in the examples, both the Illustrations and the example code.

For example, the illustration of the Adapter pattern (a pretty simple design pattern) involves an in depth discussion of versions of Mac processors and their subsequent replacements' compatibility with Linux and Windows. (In fact, the author is so wound up in this example that they even give a reference for further reading!).

A simpler (possibly more contrived) example could have illustrated the Adapter Pattern much better and made it easier to recall (this is where the Head First book is better); instead the illustration only shows how knowledgeable the author is about Macs etc. And the illustration/code example of the Two-Way Adapter pattern is again hopelessly bogged down in the details of a ludicrous scenario to enhance your understanding.

Examples should be there to illuminate the concepts presented - not to flaunt the author's prowess.

Still, in the main it's a good read with much to commend it, but the poor examples to illustrate concepts and the baffling quiz sections (based on vague and ludicrous illustrations) may frustrate some.

Very promising title but does not deliver
I am a developer working with C# 3.0 on a daily basis and so I was very excited by this book, hoping that it would give me greater insight into C# 3.0's excellent new features and some new tools in my programming toolkit, as well as more insight into design patterns and their use in designing modular, maintainable, extensible systems.

I have ploughed my way through the book, but it has taken me a while because it simply doesn't live up to expectations. The examples are not very relevant to everyday programming problems and often seem contrived and there are some annoying typos and some dubious advice (see other reviews).

Instead of this book, I would recommend a good book on design patterns and a good book on C# 3.0.

The design patterns book that every C# programmer needs

C# 3.0 Design Patterns by Judith Bishop takes a new approach to a classic subject. In so doing, Bishop imparts deep insight into what is widely considered a difficult subject and conveys practical knowledge in a concise manner that will greatly benefit any serious developer programming in C# for .NET.

After an introductory chapter entitled "C# Meets Design Patterns," there are nine chapters presenting all of the 23 classic design patterns from Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides's seminal work Design Patterns: Elements of Reusable Object-Oriented Software. The patterns are presented two or three at a time, and each chapter begins with a real-world illustration of the pattern in action. This is followed by a clear UML diagram, a concise description of the pattern players and their roles and a theory example that implements the pattern in quesiton in a complete console application that is made as short as possible, usually 50 to 80 lines of code.

After presenting each pattern, Bishop provides one or more examples, several of which are carried over to and expanded in subsequent chapters, and presents numerous exercises for the reader. Each chapter typically contains sidebars briefly describing one or more C# features and how they can be leveraged in implementing the pattern at hand. There is also excellent guidance on when to use each pattern and an invaluable comparison of the patterns presented in each chapter that provides further insight into their characteristics. In addition, all of the patterns, their interactions and the examples in which they are illustrated are summarized in the final chapter.

In a book of less than 300 pages, the examples, although highly relevant to practical programming problems, are necessarily somewhat simplistic. They do not contain any of the error checking, exception handling or test methods that would be present in industrial-strength code. Nonetheless, they are all complete programs that clearly illustrate the pattern in question and how to code it in C#. Several of the examples are also expanded over several chapters and presented in an appendix as fully functional programs that can be easily extended to provide additional functionality.

Perhaps the greatest strength of Bishop's book and its greatest benefit to C#/.NET developers is its description of advanced C# 3.0 features and how they can be leveraged to create pattern implementations that are elegant and concise. Bishop not only writes with the authority one would expect of a professor of computer science. It is also very evident that she is an educator who has considerable experience in making difficult subjects comprehensible. As Microsoft C# Senior Developer Eric Lippert puts it in his preface to the book, "C# 3.0 Design Patterns brings the frequently abstruse world of design patterns into sharp focus with pragmatic C# 3.0 implementations."

Accomplishing this in less than 300 pages is nothing short of a tour de force. I have been trying for some time to get my head around design patterns and searching for good C# implementations. Now my search is over, and I have a practical guide to understanding and implementing the patterns that I need written by an accomplished theorist, practitioner and educator.