Message from Dean - May 8th 2007
I am currently testing out a new version of the APF Bridge Component - If you notice any errors within this demo store please drop me a line.
List Price: $44.99Price: $8.45 You Save: $36.54 (81%)Prices subject to change.
Availability: Usually ships in 1-2 business days
Binding: Paperback
Dewey Decimal Number: 005.268
EAN: 9780201702651
ISBN: 0201702657
Label: Pearson Education
Manufacturer: Pearson Education
Number Of Items: 1
Number Of Pages: 256
Publication Date: December 15, 2001
Publisher: Pearson Education
Studio: Pearson Education
Related Items:
Browse for similar items by category:
Editorial Review:
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.
Average Rating: 
Rating:  -
This book, while trying to clarify the subject of implementing design patterns in VB and VB.net, mostly manages to confuse.
Since I had read the GOF book "Design Patterns : Elements of Reusable Object-Oriented Software" before I purchased this book, "visual basic design patterns" by Cooper, I was pretty familiar with the patterns and the solutions for the 23 patterns outlined by the GoF. However, Cooper manages to make his book hard to follow by not including complete code samples and by literally jumping to different examples to illustrate the same pattern. The reader is never really gets a chance to "get in the groove" with the author. It seems to me to be like a poorly edited movie with too many unneeded jump cuts in the middle of the same scene.
If you've never tried to code up the patterns in VB before ( as I hadn't), you absolutely **MUST** open and look at the completed sample code on the cd while reading the book to comprehend and "grok" the VB solutions. ... Read More
Rating: -
Other reviewer already pointed the trend of making such books. I have to say even the first book in his series (Java) is not a good book.
Comparing these books with the original GoF book, the only credit I can give the author is giving an example to each pattern, which is quite a easy job for anyone who knows both the pattern and the language. The GoF book gives much better explaination for patterns (with examples in c++). Therefore this book is only useful to someone who has no knowledge of c++. Even for these people, I would recommand to read this book with GoF book together, GoF first for understanding one pattern, then this book for example of that pattern.
Rating: -
The source code implementation of the design patterns presented in this book differ radically bewteen vb6 and vb.net (as one might presume). Unfortunately, the vast majority of the supporting text is geared towards presenting an understanding of the vb6 code. It appears as though the vb.net(vb7...) material was added as an afterthought(in a rush), probably after the book had already been largely written. The vb7 material is brief, vague and frankly incorrect in some of the examples! Please don't make your future(?) customers pay for the fact that you got caught with a finished book on a technology platform(vb6), whose sunset was imminent.
Rating:  -
As of April 2002, this was the only book to explain patterns using VB.NET code.
It is poorly edited. In the first ten pages of Chapter 2, I found three editing errors that interfered with comprehension of the materials. As I browsed much of the rest of the book, I was annoyed by having to first wade through a VB6 example before getting to the VB7 (VB.NET) example. If I want to be conversant in the still quite new (and very hot) pattern approach to OO, why would I care very much about the old version of VB?
My plan is to just study the original Gang of Four book and to put this one on the self as a reference in case I have difficulty with implementing in VB.NET.
Rating: -
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 ... Read More
Availability: Usually ships in 1-2 business days
|
Amazon Store 