Differences Between Visual Basic 6.0 and .NET Controls
TOC
Collapse the table of content
Expand the table of content

Differences Between Visual Basic 6.0 and .NET Controls

 

Paul D. Sheriff
PDSA, Inc.

November 2001

Summary: This document outlines the standard controls in Microsoft Visual Basic 6.0 and the equivalent Microsoft .NET controls. (18 printed pages)

Objectives

  • Learn which Visual Basic 6.0 ActiveX controls have equivalents in .NET
  • Learn which properties have changed in .NET Controls
  • Learn which controls are new to .NET

Assumptions

The following should be true for you to get the most out of this document:

  • You understand what ActiveX controls are
  • You have built Windows applications using Visual Basic 6.0 and ActiveX controls

Contents

Standard Control Differences
New Controls in .NET
Property Changes
General Control Changes
Differences on Standard Controls
Summary

Standard Control Differences

Microsoft .NET controls are very different internally from Microsoft® ActiveX® controls in that .NET controls are created from a hierarchy of other classes. There are several classes from which these .NET controls are inherited, each one refining and adding more functionality as you drill down to an actual control. At the top of the class hierarchy for a control is the Control class. If you create your own controls however, they will most likely inherit from the UserControl class because it contains the properties and events you need, plus it does all of the drawing of constituent controls for you.

When you start to create user interfaces with .NET, you will find that many of the controls that you knew in Microsoft Visual Basic® 6.0 are gone or have been renamed. This document outlines the standard controls in Visual Basic 6.0 and the equivalent .NET controls. Later in this document, you will learn about the specific differences in property names for each of these controls. You will find that, other than property changes and some event name changes, these controls will behave pretty much as they did in Visual Basic 6.0.

Table 1 lists the standard controls that you find in the Visual Basic 6.0 Toolbox and the .NET controls that are the equivalent. Not all of the .NET controls are covered here, but this table will give you an idea of the kind of changes that have been made to controls for .NET.

Table 1. ActiveX Controls renamed in .NET

Visual Basic 6.0 Standard Controls Equivalent .NET Controls
Picture PictureBox
Label Label
TextBox TextBox
Frame GroupBox
CommandButton Button
CheckBox CheckBox
OptionButton RadioButton
ListBox ListBox
ComboBox ComboBox
HScrollBar HScrollBar
VscrollBar VScrollBar
Timer Timer
DriveListBox N/A. Replaced by OpenFileDialog control
DirListBox N/A. Replaced by OpenFileDialog control
FileListBox N/A. Replaced by OpenFileDialog control
Shape N/A. You will now use a class in the .NET Common Language Runtime (CLR) to draw shapes.
Line N/A. You will now use a class in the .NET CLR to draw a line.
Image N/A. Use the PictureBox control to display a single image.
Data N/A. Data Binding in .NET is completely different from Visual Basic 6.0.
OLE N/A
ImageList ImageList

New Controls in .NET

In addition to the standard controls, there are a whole group of new controls in .NET. Some of these controls had equivalents in Visual Basic 6.0 and some are new. Below, you'll find a list of some of the new controls that are available for you to use in .NET.

Table 2. Standard controls available to build user interfaces

New Control Description
LinkLabel Allows you to put a hyperlink on your Windows Form. It acts just like a hyperlink you are accustomed to using within a browser.
MainMenu Helps you build a menu on your form
DataGrid Displays data from an ADO.NET dataset in a tabular format. This is very similar to the FlexGrid control in Visual Basic 6.0, but has a lot of new features.
CheckedListBox An enhanced ListBox that allows the user to choose one or more items in a list by using a checkbox that is located next to each item. To do this in Visual Basic 6.0, you set the Style property to 1-Checked.
TabControl Combines the features of both the TabStrip and SSTab controls from Visual Basic 6.0
Splitter Allows you to create an Explorer-like interface with dual panes
DomainUpDown Combines a Text Box with an UpDown arrow. Works like a Combo Box in that you are allowed to place any type of data into this list, and the user can scroll through the data by clicking the up and down arrows.
TrackBar Very similar to the old Slider control in Visual Basic 6.0
HelpProvider When you add this control to the Tray of your form, it adds HelpString, HelpTopic, and ShowHelp properties to each control on the form.
ToolTip When you add this control to the Tray of your form, it adds a ToolTip property to each control on the form.
NotifyIcon Generally only used when you are creating a Windows Service, it allows you to set the Icon that is displayed in the System Tray on your task bar. When clicked, you can display a menu or bring up any form in that program.
ContextMenu Adds another menu to your form that can then be assigned to any control on your form
OpenFileDialog Displays an OpenFile dialog box. This control used to be a method of the CommonDialog control in Visual Basic 6.0.
SaveFileDialog Displays a SaveFile dialog box. This control used to be a method of the CommonDialog control in Visual Basic 6.0.
FontDialog Displays a Font dialog box. This control used to be a method of the CommonDialog control in Visual Basic 6.0.
ColorDialog Displays a Color dialog box. This control used to be a method of the CommonDialog control in Visual Basic 6.0.
PrintDialog Displays a Print dialog box. This control used to be a method of the CommonDialog control in Visual Basic 6.0.
PrintPreviewDialog Used in combination with the PrintPreviewControl
PrintPreviewControl Allows you to print to a preview window instead of the printer
ErrorProvider When you add this control to the Tray of your form, it will add Error, IconAlignment, and IconPadding properties to each control on the form
PrintDocument Along with other classes, allows you to send a document to the printer
PageSetupDialog Displays a dialog box where the user can manipulate settings such as margins and paper orientation

Property Changes

In an effort to make property names consistent across controls, and to make them more meaningful, many property names have been changed from what they were called in Visual Basic 6.0. Some properties have been removed, as they are either no longer needed (as in the case of DDE properties), or the functionality they performed has been replaced by other controls or other methods in .NET.

Removed Common Properties

There were many properties common among all the controls in Visual Basic 6.0. Many of these properties have been removed in .NET as no longer applicable, or their functionality is now handled in a completely different manner. Table 3 shows a list of common properties on Visual Basic 6.0 controls that are not available in .NET. Later in this document, you will see their new equivalents or learn why they have been removed.

Table 3. Visual Basic 6.0 properties unavailable in .NET

Removed Property
DragIcon
DragMode
Index
LinkItem
LinkMode
LinkTimeout
LinkTopic
MouseIcon
MousePointer
OLEDragMode
OLEDropMode

New Common Properties

You will often need a common set of properties on every control. Just like you had in Visual Basic 6.0, you also have a set of properties on every control in .NET. Table 4 shows this list and gives you a description of what each new property does.

Table 4. New properties available in .NET

New Property Description
AccessibleDescription A description that will be read by the Narrator accessory. The Narrator is communication tool used by the visually impaired to have words on a computer screen read to them over their computer speaker. It is available on most Windows systems by clicking Start, clicking Programs, clicking Accessories, clicking Accessibility, and then clicking Narrator. This tool reads words as you move your mouse around the screen. When you fill in this description, and you have the Narrator tool running, it reads this description to the user.
AccessibleName The name of the control that will be reported by the Narrator accessory
AccessibleRole The role that will be reported to the user by the Narrator accessory
AllowDrop Determines whether or not the control receives drag-and-drop notifications
Anchor Determines where the control will be anchored to the form. You can choose just about any style of anchoring you want.
ContextMenu Set this property to the name of a ContextMenu control and when you click the right mouse button on this control, the control menu will be automatically displayed.
Dock Determines where this control will dock on this form. When you dock a control, the control grows and shrinks with the form but stays docked in the same location.
Locked If set to True, this control will not be moveable at design time.
Modifiers Determines the scope of the control. By default, in .NET all controls are Friend. In previous versions of Visual Basic, all controls were Public. You can now choose Private, Protected, Friend, or Public.

Changed Properties

In Visual Basic 6.0, there were four properties that had to be a part of every control. These properties were Left, Top, Width, and Height. While these properties are still available, it is preferred to use the new structures called Location and Size. Table 5 lists what these new properties are and gives a description of the structures you will find in each of these new properties.

Table 5. Location and Size properties in .NET

Property Description
Location A Point structure that gives the X and Y coordinates of where this control is located. In previous versions of Visual Basic, this was set using the Left and Top properties.
Size A Size structure that gives the width and height of the control. In previous versions of Visual Basic, this was set using the Width and Height properties.

General Control Changes

There are many changes in how controls work in .NET compared to Visual Basic 6.0. The next nine sections describe some of these changes and how they will impact your development in .NET.

Creation .of .NET Controls

One of the biggest changes in .NET compared to Visual Basic 6.0 is that the code that instantiates the controls on a form is now visible. In the past, all of this code was hidden within the ActiveX control and in the Visual Basic run time. Now you can see it by expanding the #Region section in the code behind the form. Here is a sample form that has one label, one text box, and one button control.

Public Class frmTest
    Inherits System.Windows.Forms.Form

#Region " Windows Form Designer generated code "

    Public Sub New()
        MyBase.New()

        'This call is required by the Windows Form Designer.
        InitializeComponent()

        'Add any initialization after the InitializeComponent() call

    End Sub

    'Form overrides dispose to clean up the component list.
    Protected Overloads Overrides Sub Dispose(ByVal disposing As Boolean)
        If disposing Then
            If Not (components Is Nothing) Then
                components.Dispose()
            End If
        End If
        MyBase.Dispose(disposing)
    End Sub
    Friend WithEvents Label1 As System.Windows.Forms.Label
    Friend WithEvents TextBox1 As System.Windows.Forms.TextBox
    Friend WithEvents Button1 As System.Windows.Forms.Button

    
    'Required by the Windows Form Designer
    Private components As System.ComponentModel.Container

    'NOTE: The following procedure is required by the Windows Form 
                 Designer
    'It can be modified using the Windows Form Designer.  
    'Do not modify it using the code editor.
    <System.Diagnostics.DebuggerStepThrough()> Private Sub 
                 InitializeComponent()
        Me.Label1 = New System.Windows.Forms.Label()
        Me.TextBox1 = New System.Windows.Forms.TextBox()
        Me.Button1 = New System.Windows.Forms.Button()
        Me.SuspendLayout()
        '
        'Label1
        '
        Me.Label1.Name = "Label1"
        Me.Label1.TabIndex = 0
        Me.Label1.Text = "Label1"
        '
        'TextBox1
        '
        Me.TextBox1.Location = New System.Drawing.Point(8, 80)
        Me.TextBox1.Name = "TextBox1"
        Me.TextBox1.TabIndex = 1
        Me.TextBox1.Text = "TextBox1"
        '
        'Button1
        '
        Me.Button1.Location = New System.Drawing.Point(112, 32)
        Me.Button1.Name = "Button1"
        Me.Button1.TabIndex = 2
        Me.Button1.Text = "Button1"
        '
        'frmTest
        '
        Me.AutoScaleBaseSize = New System.Drawing.Size(5, 13)
        Me.ClientSize = New System.Drawing.Size(392, 250)
        Me.Controls.AddRange(New System.Windows.Forms.Control() 
         {Me.Button1, Me.TextBox1, Me.Label1})
        Me.HelpButton = True
        Me.MaximizeBox = False
        Me.MinimizeBox = False
        Me.Name = "frmTest"
        Me.Text = "frmTest"
        Me.ResumeLayout(False)

    End Sub

#End Region

End Class

As you can see, each control is created and then the properties, such as Location and Size, are initialized. Any other properties that you set in the Property window in the Visual Studio Designer are also added as code to this section. If you really wanted to, you could design your user interface solely with Notepad!

Note   Do not change any of the code in this #Region area. This code is created and destroyed automatically by the Visual Studio environment any time you add or remove controls from the form.

Anchoring

If you are like many Visual Basic developers, you have written code to anchor controls to the bottom right edge of a form more times than you care to admit. You want users to be able to resize the form, but you want certain controls on the form to always maintain their placement relative to the bottom and/or the right edge of the form. Throw away the code! Visual Studio .NET provides a simple solution: the Anchor property. This property allows you to anchor a control to any or all of a container's edges. Anchoring to the bottom and/or right edge causes the control to float as you resize the form. Anchoring to the top and/or left edge causes the control to resize as you resize the form. You'll want to experiment with this new property, to get the hang of its effect on your controls.

Figure 1. A typical data entry screen

On a typed data entry form, like the one shown in Figure 1, you probably want any Add, Update, Delete, and Clear buttons to stay in the lower right-hand corner of the form. To accomplish this, highlight the buttons, and set the Anchor property to BottomRight. To do this, find the Anchor property in the Properties window, and click the drop-down arrow. Clear the selected bars on the top and left, and then select the bars on the bottom and right, as shown in Figure 2.

Figure 2. The Properties dialog box with the Anchor drop-down list activated

The Anchor property allows you to anchor controls to edges of forms without having to write a line of code. By selecting options from the graphic menus, you can select the behavior you need. In code, you can use constants such as TopLeft, BottomRight, Left, Right, Top, Bottom, TopLeftBottom, and All, to set the property value.

Docking

The Dock property is similar to the Anchor property in that it allows you to dock a control to any of a container's edges. When you dock a control, the control grows and shrinks with the form, but the side to which it is docked remains the same. If you dock a control to all form sides, the control will fill the entire form.

What about Control Arrays?

In Visual Basic 6.0, you set the Name property to the same value for all controls to make a control array. The Index property was then set to a different number for each control. This Index value was passed to any event for that group of controls so you knew which control invoked this event. This was one of the uses of control arrays in Visual Basic 6.0; the ability for one event procedure to handle the code for multiple controls.

In Visual Basic .NET, you handle control arrays much differently. There are two methods of having one procedure handle the events for multiple controls. You can use the AddHandler procedure that is built into the .NET classes, or you can use the Handles clause on a procedure.

If you wish to write only one Click event for each of the buttons along the bottom of the form, you can double-click one of them to have the code window generate a Click event procedure. You can then write the code that makes that procedure do something.

Private Sub btnSave_Click( _
 ByVal sender As Object, _
 ByVal e As System.EventArgs) _
 Handles btnSave.Click, btnNew.Click, btnDelete.Click
    MessageBox.Show("A Click event")
End Sub

Although the above code does not do much, it illustrates how different controls can call the same procedure. Instead of creating a control array, you can create an event handler and assign it to react to one or more events of multiple controls.

Besides the Handles clause, you can also use the AddHandler statement to have one procedure handle the events for multiple controls. This statement allows you to add an event handler to any event, specifying the procedure to call. Because you're adding event handlers to the event, you can have a series of event handlers processing the same event. In effect, you're telling the control which procedure it should call in reaction to its event. This procedure is called a delegate, as you have delegated event handling to this new procedure.

To make this delegation happen, add code like the following to your form's New method, below the TODO comment in the existing code:

AddHandler btnDelete.Click, AddressOf ButtonClick

AddHandler btnNew.Click, AddressOf ButtonClick

After adding the above code, if you click the New, Delete, or Save buttons, the ButtonClick event procedure will be called. Of course, you might need to determine which button called this particular event procedure. To do this, you can use the sender parameter that is passed to all event procedures. The sender is the object that raised this particular event. So you might write code like this:

Private Sub ButtonClick( _
 ByVal sender As Object, _
 ByVal e As System.EventArgs)
    If sender Is btnNew Then
       MessageBox.Show("New button pressed")
    ElseIf sender Is btnSave Then
       MessageBox.Show("Save button pressed")
    ElseIf sender Is btnDelete Then
       MessageBox.Show("Delete button pressed")
    End If
End Sub

There is no real difference between these two methods of setting up a control array. So feel free to use either one.

Default and Cancel Buttons

In previous versions of Visual Basic, you set a Default property to True on a CommandButton control to tell Visual Basic that when the Enter key is pressed it should invoke the Click event of this button. You set the Cancel property of another CommandButton control to tell Visual Basic that when the Esc key is pressed, it should invoke the Click event of that button. You then had to write code for each of these Click event procedures to close the form, and, most likely, set a property telling the routine that called this form which button was pressed.

You can now accomplish this without writing any code under these buttons. To do this, set the DialogResult property on each of these buttons to a specific value. For example, if you have OK and Cancel buttons on a form, you set the DialogResult to OK and Cancel on each of these buttons, respectively. You then set the form's AcceptButton property to the name of the OK button. You set the form's CancelButton property to the Cancel button.

After setting these properties, you can display the form using the ShowDialog method, and both buttons automatically close the form. The DialogResult property of the form is then set to the DialogResult value set in the button that was pressed. In this way, you can determine which button closed the form from within the calling program.

Context-Sensitive Menus

In a Windows application, you might need to assign a special menu to a control that is brought up when the right mouse button clicks this control. To accomplish this in Visual Basic 6.0, you created a menu with the Visible property set to False. You then had to write code in the Click event procedure for this control to display that hidden menu.

In .NET, you can now use the ContextMenu control to create a completely separate menu from the MainMenu of a form. You can assign this menu to a control just by setting the ContextMenu property of that control. There is no additional code to write.

Locking of Controls on a Form

After you have carefully created your user interface, you'll want to ensure that you don't accidentally move any controls while clicking on them to add code. In Visual Basic 6.0, you had the option of locking all of the controls on a form. This worked great, except in the case where you might still be working on just one little section of a large form. You had to unlock all of the controls just to work on that one section. The potential was there to accidentally move controls.

In .NET, you can lock controls either as a group or individually. This can be a big benefit when working on more than one set of controls on a large form.

Controls on MDI Form

In Visual Basic 6.0, the only controls that could be placed on an MDI form were those controls that had an Align property. In .NET, you can now place any control on an MDI form.

DDE Is Gone

Dynamic Data Exchange (DDE) is no longer available as a technology in the .NET language. There are so many other methods of communicating from one program to another that this technology is no longer needed. As a result, all of the properties prefixed with Link have been removed from all of the controls.

Differences on Standard Controls

As mentioned earlier in this document, there have been a lot of property changes to many of the standard controls. Here are the properties that have changed or have been added on each of the different standard controls. The differences outlined in the following tables are differences to properties that are specific to these controls. The common properties outlined earlier are also changed, but are not re-iterated here.

Label Control

New Property Description
Text In Visual Basic 6.0, this property was called Caption.

Text Box Control

New Property Description
AcceptsReturn If set to True, a multi-line text box will accept a CRLF as valid character. To stop a CRLF from being entered into a text box, set this property to False.
AcceptsTab If set to True, a multi-line text box will accept a tab as valid character. To stop a tab from being entered into a text box, set this property to False.
CharacterCasing Controls the case of the letters that the user types into this control. Options are Normal, UpperCase, and LowerCase.
ReadOnly Set to True if you do not want the user to be able to type into this text box. This property has the same functionality as the old Locked property.
TextAlign Controls the alignment of the text when the user types the data into the text area. You can set this property to Left, Right, or Center.

Button Control

New Property Description
BackgroundImage Allows setting a background image on the button. You can also add text on top of this image.
DialogResult Sets a result that will be returned when the form is called as a dialog. If the user presses this button, the value in this property will be returned.
FlatStyle Changes the appearance of the button. Options are Flat, PopUp, Standard, and System. If you are using Windows XP, you should always use System as this allows you to use XP Themes.
Image The image to display in this button
ImageAlign Where to place the image within the button
ImageIndex The index number of an image in the ImageList control set in the ImageList property
ImageList The name of the ImageList control where you retrieve images using the ImageIndex property
Text In Visual Basic 6.0, this property was called Caption
TextAlign Controls the alignment of the text displayed within the button. Options are left, right, center, middle, top or bottom, or any combination of these.

Check Box Control

New Property Description
AutoCheck If set to True, clicking anywhere on the control changes the Check Box state from selected to unselected.
BackgroundImage Allows you to set a background image on the Check Box control. You can also add text on top of this image.
CheckAlign Determines the position of the Check Box control. Visual Basic 6.0 limited the position to the left or right of the text within the Check Box. You may now choose left, right, up, down, or center.
Checked True=Selected, False=Unchecked
CheckState This property allows you to set three states at design time for what you want the control to display at run time. Your choices are Checked, Unchecked, or Indeterminate. NOTE: Indeterminate can only be set if the ThreeState property is set to True.
FlatStyle Changes the appearance of the Check Box control. Options are Flat, PopUp, Standard, and System.
Image An image to display in this Check Box
ImageAlign Where to place the image within the Check Box
ImageIndex The index number of an image in the ImageList control set in the ImageList property.
ImageList The name of the ImageList control where you retrieve images using the ImageIndex property
Text This property used to be called Caption in Visual Basic 6.0.
ThreeState If this property is set to True, it will allow you to set the CheckState property to Indeterminate. It will also allow the user to toggle among Checked, Unchecked, and Indeterminate.

Radio Button Control

New Property Description
AutoCheck If set to True, click anywhere on the control and the state will change from Checked to Unchecked.
BackgroundImage Allows you to set a background image on the radio button. You can also add text on top of this image.
CheckAlign Determines the position of the check within the radio button. In Visual Basic 6.0, you could only position it to the left or right of the text; you may now choose left, right, up, down, or center.
Checked This property used to be called Value in Visual Basic 6.0.
FlatStyle Changes the appearance of the radio button control. Options are Flat, PopUp, Standard, and System.
Image An image to display in this radio button
ImageAlign Where to place the image within the radio button
ImageIndex The index number of an image in the ImageList control set in the ImageList property
ImageList The name of the ImageList control where you retrieve images using the ImageIndex property
Text This property used to be called Caption in Visual Basic 6.0.
TextAlign Controls the alignment of the text displayed within the radio button. You can set this property to left, right, center, middle, top, or bottom, or any combination of these.

Combo Box Control

New Property Description
DisplayMember Displays items in the list portion of the control from each object loaded into the ComboBox. The default DisplayMember is the ToString method.
DropDownStyle This used to be called Style in Visual Basic 6.0. You have the choice of Simple, DropDownList, and DropDown just like in Visual Basic 6.0.
DropDownWidth The width, in pixels, of the drop-down portion of the combo box. This can be different from the actual size of the combo box on the form.
MaxDropDownItems Allows you to set the number of items displayed when the user uses the drops-down list portion of the combo box
MaxLength The maximum amount of characters you may enter if the DropDownStyle is set to Simple
ValueMember Retrieves data from the selected item. The default is the ToString method

List Box Control

New Property Description
ColumnWidth The width of each column when you set the MultiColumn property to True
DisplayMember Displays items in the list portion of the control from each object loaded into the ListBox. The default DisplayMember is the ToString method.
HorizontalExtent If the HorizontalScrollbar property is set to True, you can fill in this property with a number that represents the total width (in pixels) that the scroll bar can scroll
HorizontalScrollbar Set to False if you do not wish to see a horizontal scroll bar appear when data is too wide for the width of this box
ItemHeight The height of an item in the list box if using a fixed-font
Items Replaces the List property in a Visual Basic 6.0 ListBox
MultiColumn Replaces the Columns property in Visual Basic 6.0. Set this value to True if you wish to have multiple columns.
ScrollAlwaysVisible Set to True if you want a scroll bar to be present even when there is not enough data to warrant a scroll bar. This can help you determine the appropriate width for the list box, based on the data that will go into this list box. If you can see the scroll bar at run time with the data loaded, you will be better able to set the correct width of the control when the data becomes too large.
SelectionMode Replaces the MultiSelect property in Visual Basic 6.0.
UseTabStop Set to False if you do not wish to have the Tab character represent a different column in this list box.
ValueMember Retrieves data from the selected item. The default is the ToString method.

Picture Box Control

New Property Description
BackgroundImage Allows you to set a background image on the Picture Box. You can also add text on top of this image.
BorderStyle Includes a Fixed3D option in addition to None and Fixed
Image This is now used instead of the Picture property.
SizeMode Controls how the picture is displayed. The values available are Normal, StretchImage, AutoSize, and CenterImage.

HScrollBar Control

New Property Description
Maximum Replaces Max property in Visual Basic 6.0
Minimum Replaces the Min property in Visual Basic 6.0

VScrollBar Control

Property Description
Maximum Replaces Max property in Visual Basic 6.0
Minimum Replaces the Min property in Visual Basic 6.0

Other Controls

There are many other controls in addition to the standard controls in Visual Basic 6.0 that have been updated in Visual Basic .NET. In fact, there are so many, each control deserves its own document. With the changes presented in this document, you get a good idea of the types of changes that you will encounter as you work with these new controls in .NET.

Summary

There have been a lot of changes to how you create user interfaces in .NET. Some of the controls that you have used before are gone, or are very different. You will use these different properties for certain behaviors, and in some cases, you may have to use system classes instead of controls. You will find that the .NET controls improve upon the older ActiveX controls considerably. With new properties and methods, it should help you develop better Windows applications than ever before.

About the Author

Paul D. Sheriff is the owner of PDSA, Inc., a custom software development and consulting company in Southern California. Paul is the MSDN Regional Director for Southern California, is the author of a book on Visual Basic 6 called Paul Sheriff Teaches Visual Basic, and has produced over 72 videos on Visual Basic, SQL Server, .NET and Web Development for Keystone Learning Systems. Paul has co-authored a book entitled ASP.NET Jumpstart. Visit the PDSA, Inc. Web site (www.pdsa.com) for more information.

About Informant Communications Group

Informant Communications Group, Inc. (www.informant.com) is a diversified media company focused on the information technology sector. Specializing in software development publications, conferences, catalog publishing and Web sites, ICG was founded in 1990. With offices in the United States and the United Kingdom, ICG has served as a respected media and marketing content integrator, satisfying the burgeoning appetite of IT professionals for quality technical information.

Copyright © 2001 Informant Communications Group and Microsoft Corporation

Technical Editing: PDSA, Inc.

Show:
© 2016 Microsoft