Visual Basic .Net Power Tools


Step-by-Step Instruction on Complex Topics Leads You to the Expert Level

Do you scour VB.NET books seeking solutions for esoteric database programming, debugging, security, or printing challenges, but can't ever find them? Are you wrestling with VB.NET's newer topics, such as asynchronous programming, Web services, employing Office objects, using reflection, and the .NET Compact Framework? Could you use some assistance making the transition ...

See more details below
Available through our Marketplace sellers.
Other sellers (Paperback)
  • All (12) from $1.99   
  • New (2) from $18.96   
  • Used (10) from $1.99   
Sort by
Page 1 of 1
Showing All
Note: Marketplace items are not eligible for any coupons and promotions
Seller since 2005

Feedback rating:



New — never opened or used in original packaging.

Like New — packaging may have been opened. A "Like New" item is suitable to give as a gift.

Very Good — may have minor signs of wear on packaging but item works perfectly and has no damage.

Good — item is in good condition but packaging may have signs of shelf wear/aging or torn packaging. All specific defects should be noted in the Comments section associated with each item.

Acceptable — item is in working order but may show signs of wear such as scratches or torn packaging. All specific defects should be noted in the Comments section associated with each item.

Used — An item that has been opened and may show signs of wear. All specific defects should be noted in the Comments section associated with each item.

Refurbished — A used item that has been renewed or updated and verified to be in proper working condition. Not necessarily completed by the original manufacturer.

Chichester, United Kingdom 2003 Soft cover New NEW Book, Text & cover completely pristine, free of any wear. FREE TRACKING within the US (international tracking not currently ... available), and email notice when shipped. Your satisfaction guaranteed. Inquiries welcomed. Thanks. Read more Show Less

Ships from: Garland, TX

Usually ships in 1-2 business days

  • Canadian
  • International
  • Standard, 48 States
  • Standard (AK, HI)
  • Express, 48 States
  • Express (AK, HI)
Seller since 2015

Feedback rating:


Condition: New
Brand new.

Ships from: acton, MA

Usually ships in 1-2 business days

  • Standard, 48 States
  • Standard (AK, HI)
Page 1 of 1
Showing All
Sort by
Sending request ...


Step-by-Step Instruction on Complex Topics Leads You to the Expert Level

Do you scour VB.NET books seeking solutions for esoteric database programming, debugging, security, or printing challenges, but can't ever find them? Are you wrestling with VB.NET's newer topics, such as asynchronous programming, Web services, employing Office objects, using reflection, and the .NET Compact Framework? Could you use some assistance making the transition from VB6 to VB.NET? If so, peer inside.

Visual Basic .NET Power Tools is intended for professional programmers geared up to tackle the complex, cutting-edge, and sophisticated aspects of VB.NET. In this rare book, two world-renowned VB authors thoroughly describe a broad range of fascinating and important aspects of VB that aren't addressed elsewhere.

This solutions-oriented guide teaches you how to:

  • Get under the hood of the .NET Framework, and find out why it works the way it does
  • Employ serialization techniques
  • Leverage Microsoft Office in your applications
  • Master encryption, hashing, and creating keys
  • Learn advanced printing techniques
  • Use the new reflection technology to look inside executing assemblies
  • Build data-driven Web applications
  • Design data-driven Windows applications
  • Work with regular expressions
  • Employ advanced graphics techniques
  • Create professional-looking forms
  • Design effective User Interfaces
  • Use the .NET Compact Framework and its emerging technologies
Read More Show Less

Product Details

  • ISBN-13: 9780782142426
  • Publisher: Wiley
  • Publication date: 10/22/2003
  • Edition number: 1
  • Pages: 694
  • Product dimensions: 7.48 (w) x 9.06 (h) x 1.48 (d)

Meet the Author

Evangelos Petroutsos is a computer engineer who has worked for the California Institute of Technology and MCI. He writes articles, teaches programming courses, and wrote the best-selling Mastering Visual Basic .NET, Mastering VB 6, and VB 6 Developer's Handbook, from Sybex. Richard Mansfield has written hundreds of magazine articles and 32 computer books. Richard's books have sold more than 500,000 copies worldwide, and have been translated into 11 languages.

Read More Show Less

Read an Excerpt

Visual Basic .NET Power Tools

By Evangelos Petroutsos

John Wiley & Sons

ISBN: 0-7821-4242-7

Chapter One

Understanding the .NET Framework

Visual Basic .NET was not written by Visual Basic programmers. The entire .NET family of languages was created by C programmers. C-and its cohort OOP-is an academic language. Visual Basic is a popular language.

These facts have consequences. Visual Basic was conceived in 1990 specifically as an alternative to C. VB was designed as a rapid application-development language-blessedly free of cant and obscurantism. VB was created especially for the small businessman who wanted to quickly put together a little tax calculation utility, or the mother who wanted to write a little geography quiz to help Billy with his homework. VB was programming for the people. Several hundred thousand people use C; millions use Visual Basic.

As with many cultures-Rome versus Egypt, USA versus France, town versus gown-programming languages quickly divided into two camps. C and its offspring (C++, Java, C#, and others) represent one great camp of programmers. Visual Basic is the other camp. However, .NET is an attempt to merge Visual Basic with the C languages-while still retaining as much as possible of the famous populist VB punctuation (direct, clear, straightforward, English-like), syntax, and diction.

Many professors, bless them, thrive on abstraction, classification, and fine distinctions. That's one reason why VB.NET is in some ways more confusing than necessary. It has many layers of "accessibility" (scoping) and many varieties of ways to organize data, some more useful than others. It has multiple "qualification" schemes; considerable redundancy; single terms with multiple meanings (strong typing, for example); multiple terms for a single behavior (Imports versus Import); and all kinds of exceptions to its own rules.

VB.NET, however, is clearly an improvement over earlier versions of VB in many respects. We must all find ways of moving from local to distributed programming techniques. And VB.NET is also quite a bit more powerful than previous versions. For example, streaming replaces traditional file I/O, but streaming can also handle data flowing from several sources-not just the hard drive. Streaming considerably expands your data management tools. You can replace a FileStream with a WebResponse object, and send your data to a Web client.

Nonetheless, in the effort to merge all computer languages under the .NET umbrella, VB had to give up some of its clarity and simplicity. In fact, VB now produces the same compiled code that all the other .NET languages do-so under the hood, there is no longer any distinction to be made between the two linguistic cultures. It's just on the surface, where we programmers work, that the differences reside.

OOP itself, like biology, involves a complex system of classification. This means that people using OOP must spend a good amount of their time performing clerical duties (Where does this go? How do I describe this? What category is this in? Are the text-manipulation functions located in the Text namespace, or the String namespace? Does this object have to be instantiated, or can I just use its methods directly without creating the object first?)

Why Read This Chapter

If you're one of the millions of VB programmers who, like me, came upon VB.NET with the highly intelligent reaction "Whaaaaa??!!," this chapter might be of use to you.

I'm not unintelligent, and I'm assuming you're not either. But slogging through the VB.NET world makes one seem rather slow, especially at first. This chapter gives you some hard-won advice that can save you considerable confusion.

VB.NET is, of course, far easier to navigate if you have a background in C programming languages (and its lovely wife, object-oriented programming).

Millions of VB programmers deliberately decided not to use C. That's why we became VB programmers in the first place. We preferred the power of VB's rapid application development tools. We didn't care for the reverse-Polish backward syntax, the redundant punctuation (all those semicolons) and other aspects of C and its daughter languages.

The Internet changed all that-we must develop new skills and adapt to new programming styles. Leaving the cozy and predictable world of local programming (applications for Windows, running on a single computer) requires new techniques. You don't have to switch to C or its ilk, but you do have to expand your VB vocabulary and skills.

Today's programs are sometimes fractured into multiple programlets (distributed applications) residing in different locations on different hard drives and sometimes even using different platforms or languages. Web Services are the wave of the future, and this kind of computing greatly increases the impact of communication and security issues. Not to mention the necessity of encapsulating code into objects.

So gird your loins or whatever else you gird when threatened, and get ready for some new ideas. You've got to deal with some different notions.

Each of us (the authors) has written several books on VB.NET in the past few years -working within the .NET world daily for three years now-and we're still discovering new tools, concepts, and features. Part of this is simply getting to know the huge .NET Framework, and part of it is adjusting to OOP and other C-like elements that are now part of VB.

What they say of quantum mechanics applies to OOP: only ten people in the world understand it well, and nobody understands it completely. So be brave. You can learn some patterns and rules to help you get results in .NET, and the benefit is that VB.NET is quite a bit more powerful and flexible than traditional VB. There are considerable rewards for your patience and efforts.

You'll find ideas in this chapter that will deepen your understanding of the great, vast .NET environment and framework. You'll find useful information here that will improve your VB.NET programming-guaranteed. For example: What are structures, and when should you use them? (They're a replacement for classic VB's user-defined types, and you should never use them. OOP experts say that whenever you're tempted to use a structure, create a class instead-it's more flexible. Of course other OOP experts disagree, and the squabbling begins.)


A significant effect of the merging in of VB with C-style languages is that the VB.NET Help system and documentation were mostly written by C programmers. These people are not generally writers nor are they very familiar with Visual Basic. That's why you find techno-speak error messages, convoluted descriptions in the Help system, and other foggy patches.

So, instead of VB's justly acclaimed clarity, we get Help descriptions that sound like they were written by a barmy IRS bureaucrat. Here's an example:

Changing the value of a field or property associated with any one instance does not affect the value of fields or properties of other instances of the class. On the other hand, when you change the value of a shared field and property associated with an instance of a class, you change the value associated with all instances of the class.

Got it?

Not only is the VB.NET documentation all-too-often puzzling, the fact that C programmers wrote it means that the descriptions and even the source code examples are often some half-English, half-C beast.

Many Help source code examples listed as "VB.NET" versions are, in fact, written by C programmers. VB programmers must spend the time to translate this faux VB code. It's great that there is now so much tested, bug-free example code in Help. However, perhaps Microsoft would be wise to ask experienced VB programmers to go over the pseudo "Visual Basic" code examples, and translate them into actual VB-style programming.

For example, take a look at the entry in Help for String.IndexOf. If you scroll down the right pane, you can see all the ways that the sample code is not typical VB code. Many VB programmers will have to figure out how to actually make this code work. It can't just be copied and pasted.

VB programmers can be confused by some of the strange punctuation and other odd qualities of the following, and many other examples you find in Help. Although nominally Visual Basic source code, too many Help examples are alien in many particulars, as you can see in this sample code illustrating the IndexOf method:

Imports System Class Sample Public Shared Sub Main()

Dim br1 As String = _ "0-+-1-+-2-+-3-+-4-+-5-+-6-+-" Dim br2 As String = _ "0123456789012345678901234567890123456789012345678901234567890123456" Dim str As String = _ "Now is the time for all good men to come to the aid of their party." Dim start As Integer

Dim at As Integer Dim [end] As Integer Dim count As Integer [end] = str.Length start = [end] / 2 Console.WriteLine() Console.WriteLine("All occurences (sic) of 'he' from position {0} to {1}.", _ start, [end] - 1) Console.WriteLine("{1}{0}{2}{0}{3}{0}", Environment.NewLine, br1, br2, str) Console.Write("The string 'he' occurs at position(s): ")

count = 0 at = 0 While start <= [end] AndAlso at > - 1 ' start+count must be a position within -str-. count = [end] - start at = str.IndexOf("he", start, count) If at = - 1 Then Exit While End If Console.Write("{0} ", at) start = at + 1 End While Console.WriteLine() End Sub 'Main

End Class 'Sample

This example was obviously written by a C programmer who had little experience with Visual Basic programming. There are several giveaways. First is the use of a class to illustrate a simple, small programming technique. Creating a class for this purpose is overkill, though some strict OOP enthusiasts insist that everything in programming must be an object.

Also, Visual Basic programmers almost never use Sub Main. Instead, we use the Form1_Load event as the startup object. For one thing, this event is the default startup object in Visual Basic. Programmers using languages that are not form-based, such as C, employ Sub Main as their entry point when a program begins execution. There is no default Form1 in C, so C programmers are accustomed to starting their programs in Sub Main (which is where they put initialization code, and also where they test short code samples).

To make the many "VB" code samples in Help work, a VB.NET programmer must right-click the project name in Solution Explorer, choose Properties, then manually adjust the startup object in a Property Pages dialog box.

Another giveaway that this isn't true VB is the line Imports System. VB.NET programmers know that by default the System namespace is always available and need not be imported.

Also, VB.NET programmers do not use the brace {} symbols to fill in fields when displaying results, nor do we use the word End as a variable name, requiring that it be enclosed in brackets .

In fact, until VB.NET, the Visual Basic language didn't even permit the use of braces, semicolons, or brackets. Blessed simplicity, including the avoidance of extraneous junk punctuation, has always been a hallmark of Visual Basic.

To make this usable, to-the-point, Visual Basic-style sample code, you have to eliminate the C-flavored elements. What follows is a simplified, and pure-VB.NET, translation of this same sample. In addition to being written in recognizable VB programming style, it also has the advantage of focusing on IndexOf, the method being illustrated. The example displayed above from Help is overly complex: involving a loop, word counting, and one of the less frequently used of the IndexOf method's overloaded variations. The idea that the example is supposed to be demonstrating gets lost in a mess of irrelevancies. To be really helpful to VB programmers, Help code and Help narrative explanations should be written by a professional writer/programmer, not simply someone technically competent, with a strong C bias. And the example code should simply illustrate the method being explained, like this:

Private Sub Form1_Load(ByVal sender As System.Object, _ ByVal e As System.EventArgs) Handles MyBase.Load

Dim s As String = _ "Now is the time for all good men to come to the aid of their party."

Dim found As Integer = s.IndexOf("men")


End Sub

Grappling with Framework Class Descriptions

You have to learn how to translate the class descriptions in the Object Browser, online documentation, or Help into useable VB code. Sure, there's example code in many Help entries, but that code all too often doesn't precisely demonstrate the syntax you are looking for (it was written by C programmers, after all).

Other entries offer no example code at all. There are tens of thousands of members in VB.NET, each with its own signature (parameter list) or set of signatures (thanks to overloading). And as you'll see in this chapter, even seemingly similar classes can require quite different instantiation and different syntactic interactions with other classes to accomplish a particular job.

You therefore frequently have to read a description in Help, the Object Browser, or other documentation and then translate that description into executable source code.

Press Ctrl+Alt+J to open the VB.NET Object Browser. Locate System.IO.File, then in the right pane locate the first version of the Create method, as shown in Figure 1.1. In the lower pane, you see this information:

Public Shared Function Create(ByVal path As String) As System.IO.FileStream Member of: System.IO.File

Summary: Creates a file in the specified path.

Parameters: path: The path and name of the file to create.

Return Values: A System.IO.FileStream that provides read/write access to the specified file.

Many VB programmers aren't used to having to interpret this kind of information-VB used to be a simpler language. Now, with VB.NET, it's a new ball game.

You are certain to find yourself often looking at something like the description in Figure 1.1, and wondering how to change this into source code.

The Hunt for a Grammar

We want to think that there is an underlying set of rules, a grammar, that organizes .NET source code. We want to learn the rules so we can instantiate objects, and invoke their methods, without having to continually make educated guesses, then see error messages, then try again by adjusting the syntax, punctuation, or phrasing. We want to assume that the grammar of .NET is consistent-so we don't have to struggle time and again with constructions that follow no particular pattern.

Too bad. What we want isn't always what we get. For all its power and virtues, .NET is riddled with idiosyncratic, patternless constructions. Solecisms abound.

The situation is similar to the way that prepositions are used in English. There are no fixed rules that govern prepositions, yet they serve to shade the meaning of many sentences. Probably the single most obvious clue that a speaker is relatively illiterate (once they get verb forms figured out) is the misuse of prepositions. Because there are no rules, each person refines his use of prepositions by listening to educated speakers (not local TV reporters) and reading well-written text (not local newspaper stories). For example, many people use the preposition for inappropriately-using it as an all-purpose substitute when they don't know the correct preposition. An example: "There's a good chance for rain." (Should be "of.")

Having worked with VB.NET on a daily basis for years now, I can tell you that your educated guesses about writing instantiation code and how to employ other syntaxes will improve over time. But you'll never discover any fixed, reliable rules. There are too many exceptions, too many peculiarities.

Here's an illustration. The first confusion when trying to grammatically diagram the items shown in Figure 1.2 comes from the fact that two classes appear to be working together to accomplish the job of creating "a file in the specified path": System.IO.FileStream and System.IO.File. Both a filestream and a file object must be used in your code. However, since they both belong to the System.IO namespace, you need only import that single namespace:

Imports System.IO

The namespaces that are automatically added as defaults to each VB.NET Windows-style project are: System, System.Data, System.Drawing, System.Windows.Forms, and System.XML. These defaults, however, have changed in the past, and are likely to change in the future. One wonders: Why include the little used System.Drawing as a default namespace?

In addition, .NET automatically includes some less visible default namespaces-as you'll see later in this chapter in the section titled "Assemblies Three Ways."


Excerpted from Visual Basic .NET Power Tools by Evangelos Petroutsos Excerpted by permission.
All rights reserved. No part of this excerpt may be reproduced or reprinted without permission in writing from the publisher.
Excerpts are provided by Dial-A-Book Inc. solely for the personal use of visitors to this web site.

Read More Show Less

Table of Contents


Chapter 1: Understanding the .NET Framework.

Chapter 2: New Ways of Doing Traditional Jobs.

Chapter 3: Serialization Techniques.

Chapter 4: Leveraging Microsoft Office in Your Applications.

Chapter 5: Understanding .NET Security.

Chapter 6: Encryption, Hashing, and Creating Keys.

Chapter 7: Advanced Printing.

Chapter 8: Upon Reflection.

Chapter 9: Building Bug-Free and Robust Applications.

Chapter 10: Deploying Windows Applications.

Chapter 11: Building Data-Driven Web Applications.

Chapter 12: Peer-to-Peer Programming.

Chapter 13: Advanced Web Services.

Chapter 14: Building Asynchronous Applications with Message Queues.

Chapter 15: Practical ADO.NET.

Chapter 16: Building Middle-Tier Components.

Chapter 17: Exploring XML Techniques.

Chapter 18: Designing Data-Driven Windows Applications.

Chapter 19: Working with Regular Expressions.

Chapter 20: Advanced Graphics.

Chapter 21: Designing the User Interface.

Chapter 22: Using the .NET Compact Framework and Its Emerging Technologies.


Read More Show Less

Customer Reviews

Be the first to write a review
( 0 )
Rating Distribution

5 Star


4 Star


3 Star


2 Star


1 Star


Your Rating:

Your Name: Create a Pen Name or

Barnes & Review Rules

Our reader reviews allow you to share your comments on titles you liked, or didn't, with others. By submitting an online review, you are representing to Barnes & that all information contained in your review is original and accurate in all respects, and that the submission of such content by you and the posting of such content by Barnes & does not and will not violate the rights of any third party. Please follow the rules below to help ensure that your review can be posted.

Reviews by Our Customers Under the Age of 13

We highly value and respect everyone's opinion concerning the titles we offer. However, we cannot allow persons under the age of 13 to have accounts at or to post customer reviews. Please see our Terms of Use for more details.

What to exclude from your review:

Please do not write about reviews, commentary, or information posted on the product page. If you see any errors in the information on the product page, please send us an email.

Reviews should not contain any of the following:

  • - HTML tags, profanity, obscenities, vulgarities, or comments that defame anyone
  • - Time-sensitive information such as tour dates, signings, lectures, etc.
  • - Single-word reviews. Other people will read your review to discover why you liked or didn't like the title. Be descriptive.
  • - Comments focusing on the author or that may ruin the ending for others
  • - Phone numbers, addresses, URLs
  • - Pricing and availability information or alternative ordering information
  • - Advertisements or commercial solicitation


  • - By submitting a review, you grant to Barnes & and its sublicensees the royalty-free, perpetual, irrevocable right and license to use the review in accordance with the Barnes & Terms of Use.
  • - Barnes & reserves the right not to post any review -- particularly those that do not follow the terms and conditions of these Rules. Barnes & also reserves the right to remove any review at any time without notice.
  • - See Terms of Use for other conditions and disclaimers.
Search for Products You'd Like to Recommend

Recommend other products that relate to your review. Just search for them below and share!

Create a Pen Name

Your Pen Name is your unique identity on It will appear on the reviews you write and other website activities. Your Pen Name cannot be edited, changed or deleted once submitted.

Your Pen Name can be any combination of alphanumeric characters (plus - and _), and must be at least two characters long.

Continue Anonymously
Sort by: Showing 1 Customer Reviews
  • Anonymous

    Posted January 3, 2005

    Best Book!

    Read the book cover to cover and I consistently use it as a reference manual. The book covers everything from data types, to data grids, to deploying your applications. The only weak point in the book was its references to RSA encryption. However the other encryption topics in this book were fabulous. This book is a must have.

    Was this review helpful? Yes  No   Report this review
Sort by: Showing 1 Customer Reviews

If you find inappropriate content, please report it to Barnes & Noble
Why is this product inappropriate?
Comments (optional)