Visual Basic Design Patterns VB 6.0 and VB.NET (With CD-ROm) (Paperback)

~ (Author)

Editorial Reviews

Amazon.com Review

Suitable for Visual Basic developers of all levels, Visual Basic Design Patterns brings the powerful concept of reusable software patterns to the world's most popular programming language. While C++, Java, and Smalltalk programmers have long had recourse to hundreds of reusable object-oriented designs, this fascinating and very approachable text puts these powerful design concepts into reach for working VB programmers.

One of the most important (and popular) computer titles in recent memory, Design Patterns: Elements of Reusable Object-Oriented Software, brought patterns to C++ and Smalltalk programmers in 1995. The goal of Visual Basic Design Patterns is to translate the 23 designs (or patterns) outlined in that influential text into a VB setting.

First, Cooper establishes the object-oriented features in Visual Basic 6 and its support for classes and objects. Then it's on to Unified Modeling Language (UML) class diagrams for documenting the "shape" of each pattern. Next comes a tour of the new-and-improved object support in Visual Basic .NET. With the arrival of .NET in 2002, VB became a full-fledged object-oriented language. (Included here is an overview of .NET features and APIs needed to work with basic data types, collections, and files.)

The author largely succeeds in making patterns approachable. Using creational patterns like factories and builders, you'll learn how to create objects more flexibly. Structural patterns, like the adapter and composite patterns, show off how classes can relate to one another beyond simple inheritance. Behavioral patterns like the chain of responsibility and interpreter patterns show off how to add more functionality to your VB projects. Illustrated with clear examples, many using built-in features of VB such as controls or other existing classes, Cooper shows that patterns are readily available for most any developer. Several examples make use of employee classes for modeling an organization, and this allows the author to connect some of the material between sections. For each pattern, you'll get VB 6 and VB .NET versions of code (though, of course, VB .NET makes it easier to model classes with inheritance where required).

This timely volume arrives just as VB .NET brings Visual Basic to the first rank of object-oriented languages with "true" inheritance and other advanced class design features. Surprisingly enough, inheritance is just the tip of the iceberg when it comes to getting objects to work together. While C++ and Java programmers have made use of the library of patterns presented here to do more with classes, VB programmers can now benefit from the same expertise in a format that is definitely a lot more approachable than the original. If history is any cue, Visual Basic Design Patterns should become as indispensable to VB developers as the original software patterns book was to an earlier generation of developers in other languages. --Richard Dragan

Topics covered: Introduction to software design patterns; basic UML diagrams (including inheritance and composition); classes and objects in Visual Basic and VB .NET; object-oriented programming basics; building custom VB user-interface controls; inheritance and interfaces; VB .NET quick start (data types and basic programming tutorial with simple objects); VB .NET APIs for arrays, collections, and file I/O; creational patterns: simple factories, abstract factories, singletons, builder, and prototype patterns; structural patterns: adapters (used with data grids), the bridge pattern, the composite pattern (an employee class hierarchy), the decorator pattern (with ActiveX controls), the façade pattern (used with databases), the flyweight and proxy patterns; behavioral patterns: chain of responsibility (used with a help system), the command pattern (implementing "undo"), the interpreter pattern (for a report language), the iterator pattern (and VB .NET collections), the mediator pattern (used with UI controls), the memento, observer, and state patterns, the strategy pattern (used with graphical plots), the template pattern, and the visitor pattern (used with employee classes).

Product Description

Written from a Visual Basic perspective, this guide intends to make you comfortable with using design patterns by laying out the concept of patterns in a practical fashion. Provides one or more complete working visual examples of programs using that pattern, along with UML diagrams illustrating how the classes interact. Softcover. CD-ROM included.

See all Editorial Reviews

Product Details

• Paperback: 256 pages
• Publisher: Pearson Education (December 15, 2001)
• Language: English
• ISBN-10: 0201702657
• ISBN-13: 978-0201702651
• Product Dimensions: 9.2 x 7.3 x 1 inches
• Shipping Weight: 1.7 pounds (View shipping rates and policies)
• Average Customer Review: 2.5 out of 5 stars  See all reviews (8 customer reviews)
• Amazon.com Sales Rank: #590,637 in Books (See Bestsellers in Books)

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

  #58 in

  Books > Computers & Internet > Programming > Languages & Tools > Basic

Customer Reviews

Most Helpful Customer Reviews

9 of 9 people found the following review helpful:

4.0 out of 5 stars The 23 well-known patterns described by the GoF, now in VB, January 14, 2002

By	Daniel Moth (Seattle, WA) - See all my reviews (REAL NAME)

There is no argument that "Design Patterns" by the Gang of Four is a seminal piece and essential reading for any professional OO developer. There has long been a need for those patterns (illustrated in OMT with examples in C++) to be described in UML and VB. Mr Cooper fills that gap.

The author starts off by explaining what design patterns are; this is one of the best introductions to the topic that I have read. The following 7 chapters introduce UML, OO Programming and VB.NET. In my opinion, these topics cannot be explained in fewer than 100 pages of any book and hence should have been prerequisites on our part (the readers). The result is that the coverage is neither broad nor deep, but nevertheless serves at getting us all on level ground.

The remainder 360 pages focus on describing all the patterns found in the Gamma et al book. It is all very good stuff doing justice to the title, as every pattern description (bar one) is accompanied by examples in both VB6 and VB.NET. Books are coming out continuously that describe various areas of the .NET framework, of the VB language, migration issues etc. It is pleasant to see a book that discusses the deeper aspect of programming good OO software using infamous design patterns.

Depending on your programming domain, you will be delighted or disappointed that almost all examples are GUI based (no component stuff here). Also, this is not a book from one VB programmer to another. On contrary, it is evident that the author's first language is not VB and references to Java/Smalltalk can be found in the text. Irrelevant as that may be, I would have preferred to have seen events (VB6) and delegates (VB.NET) to have been leveraged in the patterns.

To finish on a positive note, this book (and the CD with all examples' code that accompanies it) serves as a good reference while writing software in VB6 and VS.NET

10 of 11 people found the following review helpful:

3.0 out of 5 stars Too language-neutral, February 27, 2002

By A Customer

Lately we have witnessed a trend in programming books: the author wrote one book and then published it using multiple programming languages using some "smart" organization of the book material. This book is yet another example (it has a Java version).

The problem with this approach, and this book in particular, is that the author tend to ignore the language specific features to make his/her life easier. And this is precisely the problem with this book: the author could as well have published even more language versions because the discussion is so "language-neutral" and all the examples given are so un-VB... I can easily imagine the same examples implemented with Tcl/Tk or Delphi or any other modern programming language, for that matter.

Let's face it. We choose a lanaguage for a certain task because the language has certain desirable feature(s) to make our life easier: the right tool for the right job. As such the approach taken in this book is flawed: "OK, we've got this pattern in GoF, so let's see how we can implement this in VB and VB.NET using the smallest feature set possible" (actually I suspect it's the feature set that intersects with Java most). So we end up with patterns implemented in the "obvious way", which for almost all languages is not the preferrable way because there are probably some specific language features to exploit. This book doesn't, in particular, take advantage of the language's greatest strength: COM integration. Why would a VB programmer choose not to use COM when it is possible, and in many cases more suitable, to implement the design patterns dicussed?

I seriously recommend you to first glance through this book (in person) before you buy it. Better yet, also check out Stamatakis' VBDP book. (Yes, this one uses COM.)

5 of 5 people found the following review helpful:

3.0 out of 5 stars Pretty good, but code snippets are hard to follow, April 19, 2002

By	larryq (California) - See all my reviews

The author means well, in trying to touch on all of the design patterns mentioned in the GoF book (showing how each pattern might be implemented in VB 6 and VB .Net), but the code snippets in the book are often too difficult to follow, sad to say. In reading the sample code, there are many points at which you ask yourself: "What does this variable do? Where did it come from? What the..."

It's not that his code is faulty, it all makes sense when you open up the CDRom and go through things slowly, but the snippets in the book are too sparse to really follow without having your computer on and the VB projects open before you. This "sparseness" was likely done to keep the book's length down some, and if you don't mind looking at your monitor as you read the chapters then I suppose you'll do ok.

My inclination however, is to read the chapters first, *then* look at the code, and I just couldn't do that here and make sense of things. Also, I didn't particularly enjoy some of the sample programs (I thought the "swim meet" samples were somewhat convoluted, for instance), but that could just be my problem.

Now that the critiques are out of the way, I'll give the author credit for doing a good job in explaining why you would use design pattern XYZ and under which circumstances, and for listing pattern examples in both VB 6 and VB .Net. It's certainly not a bad book, just a little tough to follow without VB sitting open next to you.