You are previewing Upgrading Visual Basic® 6.0 Applications to Visual Basic .NET and Visual Basic 2005.
O'Reilly logo
Upgrading Visual Basic® 6.0 Applications to Visual Basic .NET and Visual Basic 2005

Book Description

Expert guidance for upgrading Visual Basic 6.0 applications to Visual Basic .NET and Visual Basic 2005.

Table of Contents

  1. Copyright
  2. Preface
    1. Who Should Read This Guide
      1. For Technical Decision Makers
      2. For Solution Architects
      3. For Developers
    2. Prerequisites
    3. How to Use This Guide
      1. Relevant Chapters for Technical Decision Makers
      2. Relevant Chapters for Solution Architects
      3. Relevant Chapters for Software Developers
    4. Document Conventions
    5. Feedback and Support
    6. Principal Authors
    7. Contributors
    8. Acknowledgements
    9. More Information
  3. 1. Introduction
    1. Why Consider an Upgrade Project?
      1. Minimum Information Needed to Make a Decision
        1. Business Value Assessment
        2. Code Quality Assessment
        3. Development Environment Assessment
        4. Upgrade, Reuse, Rewrite, or Replace?
        5. Partial Upgrade
    2. Upgrade Strategies
    3. Moving from Visual Basic 6.0 to Visual Basic .NET
      1. Increased Productivity
      2. Better Integration
      3. Application Extendibility
      4. Improved Reliability
      5. Improved Security
      6. Improved Deployment Options
      7. Increased Performance
      8. Technical Support
      9. Benefits of the Visual Basic 6.0 to Visual Basic .NET Upgrade Wizard
    4. Summary
    5. For More Information
  4. 2. Practices for Successful Upgrades
    1. Functional Equivalence and Application Advancement
      1. Functional Equivalence
      2. Application Advancement
    2. Organizational Structure and the Software Life Cycle
    3. Overview of the Upgrade Process
    4. Proof of Concept
    5. Planning the Upgrade
      1. Defining the Project Scope
      2. Performing an Application Analysis
      3. Assessing the Current and the Target Architectures
      4. Analyzing and Designing New Functionality
      5. Selecting an Upgrade Strategy
        1. Complete Upgrade
        2. Staged Upgrade
          1. Vertical Upgrade
          2. Horizontal Upgrade
        3. Testing
      6. Making an Inventory of Source Code
      7. Preparing the Source Code
      8. Preparing to Handle Upgrade Issues
        1. Obtaining Source Code Metrics
        2. Identifying Unsupported Features
        3. Assessing the Upgrade Report Information
    6. Producing a Project Plan
    7. Estimating Cost
    8. Preparing for the Upgrade
      1. Preparing the Development Environment
        1. Visual Studio 6.0
        2. Visual Basic 6.0 Code Advisor
        3. Visual Studio .NET
        4. Visual Basic Upgrade Wizard
        5. ASP to ASP.NET Migration Assistant
      2. Preparing the Visual Basic 6.0 Source Code
      3. Upgrading Applications Written in Earlier Versions of Visual Basic
      4. Verifying Compilation
    9. Upgrading the Application
    10. Testing and Quality Assurance
    11. Deployment
      1. Assemblies
        1. Private and Shared Assemblies
        2. Versioning
        3. Side-by-Side Execution
        4. Configuration
        5. Update Deployment
      2. Microsoft Windows Installer
    12. Advancing an Application
    13. Managing an Upgrade Project
      1. Change Management
        1. Using Source Control
        2. Dangers of Multiple Check-Outs and File Merging
        3. Source Branches
      2. Managing the Project after Using the Upgrade Wizard
        1. Handling Non-Compiling Files with Complex Dependencies
        2. Prioritizing File Compilation
        3. Shortcuts for Getting Files to Compile
        4. Divide and Conquer
      3. Upgrade Project Complications
        1. Managing a Continuously Developing Visual Basic 6.0 Application
        2. Dealing with Strict Compilation Requirements on Checked-In Source Code
        3. Handling Multiple Visual Basic 6.0 Projects with Shared Files
        4. Handling Circular Dependencies in Visual Basic 6.0 Projects
        5. Managing a Partial Upgrade
      4. Using Historical Information
      5. Best Practices for Performing Your Upgrade
      6. Avoiding a Common Pitfalls
    14. Summary
    15. More Information
  5. 3. Assessment and Analysis
    1. Introduction
      1. Project Scope and Priorities
        1. Identifying Components That Must Be Upgraded
        2. Identifying Obsolete Components
        3. Managing Upgrade Expectations
      2. Planning
        1. Identifying Components Requiring Significant Upgrade Effort
        2. Quantifying the Amount of Code to Upgrade
        3. Determining Upgrade Order
        4. Assessing the Necessary Technical Expertise
        5. Estimating Time and Cost
        6. Defining Priorities
    2. Evaluating Upgrade Objectives
      1. Business Objectives
        1. Minimizing Organizational Disruption
        2. Leveraging Existing Knowledge Capital
        3. Reducing Risk
        4. Maximizing Return on Investment
        5. Achieving Functional Equivalence
        6. Dealing with an End to Official Support for Visual Basic 6.0
      2. Technical Objectives
        1. Adding New Functionality
        2. Achieving Better Performance and Scalability
        3. Accelerating the Development Process
        4. Consolidating to a Single Framework
        5. Ease of Deployment
      3. Gathering Data
      4. Assessing Application Usage
        1. Use Case Analysis
          1. Examples of Use Cases
          2. Creating New Use Cases
          3. Getting Information from Use Cases
        2. Inputs/Outputs Analysis
          1. Examples of Inputs
          2. Examples of Outputs
          3. Getting Information from Inputs/Outputs
      5. Application Environment
    3. Application Analysis
      1. Using the Assessment Tool
      2. Current and Target Architecture
      3. Inventory to Upgrade
      4. Source Code Metrics
      5. Handling Unsupported Features
      6. Application Dependences
      7. Missing Application Elements
    4. Estimating Effort and Cost
      1. Methodology Overview
      2. Aspects to Be Estimated
      3. Understanding the Effort – Total Worksheet
        1. Application Preparation
        2. Application Conversion
        3. Testing and Debugging
        4. Understanding the Estimate
      4. Understanding the Configuration Settings
        1. Config – General
        2. Config – By Resources
        3. Config – Fixed Tasks
        4. Config – EWIs
    5. Summary
    6. More Information
  6. 4. Common Application Types
    1. Identifying and Upgrading Application Types
      1. Determining Application Type and Functional Equivalency
      2. Determining Component and Project Types
    2. Desktop and Web Applications
      1. Architecture Considerations
        1. Single-Tier Applications
        2. Redesigning Your Single-Tier Application
        3. Two-Tier Applications
        4. Three-Tier Applications
      2. Desktop Applications
      3. Web Applications
        1. Coexistence
        2. The ASP to ASP.NET Migration Assistant
        3. Porting the ASP Application to ASP.NET
        4. Key Considerations
    3. Application Components
      1. Native DLLs and Assemblies
        1. Versioning Problems
        2. The Assembly Solution
      2. Interoperability Between .NET and COM
      3. Reusable Libraries
      4. ActiveX Controls
      5. ActiveX Controls Embedded in Web Pages
      6. ActiveX Documents
    4. Distributed Applications
      1. DCOM Applications
        1. Using COM to Upgrade a Distributed Application
        2. Using .NET Remoting to Upgrade a Distributed Application
      2. MTS and COM+ Applications
        1. Upgrade Strategy
        2. General Considerations for COM+ Visual Basic 6.0 Projects
        3. Unsupported Functionality
    5. Summary
    6. More Information
      1. Footnotes
  7. 5. The Visual Basic Upgrade Process
    1. Procedure Overview
    2. Application Preparation
      1. Development Environment Preparation
        1. System Resources
        2. External Dependencies
      2. Upgrade Wizard Preparation
        1. Visual Basic 6.0 Upgrade Assessment Tool
        2. Visual Basic 6.0 Code Advisor
      3. Removing Unused Components
      4. Obtaining the Application Resource Inventory
      5. Compilation Verification
      6. Project Upgrade Order Definition
      7. Determine All Dependencies
      8. Reviewing the Upgrade Wizard Report
    3. Application Upgrade
      1. Execution of the Visual Basic Upgrade Wizard
        1. Accessing the Upgrade Wizard from Visual Studio .NET
        2. Accessing the Upgrade Tool from the Command Line
        3. Command Line Options
        4. Project Group Upgrade
      2. Verifying the Progress of the Upgrade
      3. Fixing Problems with the Upgrade Wizard Execution
      4. Completing the Upgrade with Manual Changes
        1. Reaching a Buildable State
        2. Common Compilation Errors
          1. Problems with As Any Parameter Type
          2. Changes to Properties of Commonly Used Objects
          3. Discontinued Support for GoSub
          4. Changes in Multiple Document Interface Form (MDI) ActiveForm
    4. Testing and Debugging the Upgraded Application
      1. Upgrade Report Issues
      2. Fixing Run-Time Errors
        1. Changes to User-Defined Types
        2. Changes to Null and IsNull
        3. Changes to Array Indexing
        4. Changes to the Activate Event
        5. Changes to ComboBox Control Events
    5. Summary
    6. More Information
  8. 6. Understanding the Visual Basic Upgrade Wizard
    1. Using the Upgrade Tool
    2. Tasks Performed by the Upgrade Wizard
      1. Code Modification
      2. Reference Checking
        1. The ArtinSoft Visual Basic Upgrade Wizard Companion
      3. The Upgrade Report
    3. Supported Elements
      1. Visual Basic 6.0 Language Elements
        1. Declarations
        2. Routines
        3. Properties
        4. Event Handlers
        5. Control Structures
        6. Modules and Classes
        7. Interfaces
        8. Web Classes
        9. Late Binding
        10. Type Casts
        11. Enums
        12. User-Defined Types
          1. UDTs and the Upgrade Wizard
          2. Upgrading UDTs with Fixed-Length Fields
      2. Visual Basic 6.0 Native Libraries (VB, VBA, VBRUN)
      3. Visual Basic 6.0 Objects
        1. Forms
        2. Resources
        3. Form Resources
        4. Source Code Reorganization
        5. Measurement Unit Conversion
        6. Visual Basic 6.0 Native Controls
        7. Control Arrays
        8. Data Environments
      4. ActiveX
        1. Upgrading ActiveX Components
        2. ActiveX Controls Upgraded to .NET Intrinsic Controls
        3. User Controls
    4. Summary
    5. More Information
  9. 7. Upgrading Commonly-Used Visual Basic 6.0 Objects
    1. Upgrading the App Object
    2. Upgrading the Screen Object
    3. Upgrading the Printer Object
    4. Upgrading the Printers Collection
    5. Upgrading the Forms Collection
    6. Upgrading the Clipboard Object
    7. Upgrading the Licenses Collection
    8. Upgrading the Controls Collection
    9. Summary
    10. More Information
  10. 8. Upgrading Commonly-Used Visual Basic 6.0 Language Features
    1. Resolving Issues with Default Properties
    2. Resolving Issues with Custom Collection Classes
    3. Dealing with Changes to Commonly-Used Functions and Objects
    4. Dealing with Changes to TypeOf
    5. Upgrading References to Visual Basic 6.0 Enum Values
      1. Defining Your Own Constant Values
      2. Using the Non-Constant Values
    6. Dealing with Changes to Arrays
      1. Legacy Visual Basic Language Features
    7. Upgrading Add-ins
    8. Summary
    9. More Information
  11. 9. Upgrading Visual Basic 6.0 Forms Features
    1. Handling Changes to Graphics Operations
      1. Removal of the Line Control in Visual Basic .NET
      2. Removal of the Shape Control in Visual Basic .NET
    2. Handling Changes to the PopupMenu Method
    3. Handling Changes to the ClipControls Property
    4. Drag-and-Drop Functionality
      1. Drag-and-Drop Functionality in Visual Basic 6.0
      2. Drag-and-Drop Functionality in Visual Basic .NET
    5. Handling Changes to the MousePointer and MouseIcon Properties
    6. Handling Changes to Property Pages
    7. Handling Changes to the OLE Container Control
    8. Handling Changes to Control Arrays
      1. Event Handling
      2. Accessing Control Arrays as a Collection
      3. Adding Controls Dynamically
    9. Handling Changes to DDE Functionality
    10. Summary
    11. More Information
  12. 10. Upgrading Web Applications
    1. Upgrading ActiveX Documents
    2. Upgrading Web Classes
    3. Summary
  13. 11. Upgrading String and File Operations
    1. Operations Handled by the Upgrade Wizard
      1. Auto-Upgraded String Operations
      2. Auto-Upgraded File Operations
        1. Accessing Text Files
        2. Accessing Fixed-Length Records Using User-Defined Types
    2. Manual String and File Operation Changes
      1. Replacing Strings with StringBuilders
      2. Replacing Complex String Manipulation with Regular Expressions
      3. Improving File I/O with Streams
      4. File Access Through the File System Object Model
    3. Summary
    4. More Information
  14. 12. Upgrading Data Access
    1. General Considerations
    2. ActiveX Data Objects (ADO)
      1. Upgrading ADO Data Binding
      2. Projects without ADO Data Binding
      3. Upgrading Data Environment
      4. Upgrading Data Environment with Data Binding
    3. Data Access Objects and Remote Data Objects
      1. Data Binding Upgrade Considerations
      2. DAO/RDO in Visual Basic .NET
      3. Replacing the Data Control with ADO Data Control in Visual Basic 6.0
      4. Replacing DAO/RDO with ADO in Visual Basic 6.0
      5. Upgrading DAO/RDO without Data Binding
      6. Upgrading Data Access Objects (DAO)
        1. DAO with Data Binding
        2. DAO without Data Binding
      7. Upgrading Remote Data Objects (RDO)
        1. RDO with Data Binding
        2. RDO without Data Binding
        3. Replacing RDO with ADO in Visual Basic 6.0
          1. Establishing a Connection to a Database
          2. Running a Basic Query
          3. Displaying a Result Set in a MSHFlexGrid Control
        4. Replacing the RDO Remote Data Control with ADO Data Control in Visual Basic 6.0
    4. Custom Data Access Components
      1. Upgrading to a .NET Version of the Component
      2. Using COM Interop with Custom Data Access Components
      3. Upgrading Mixed Data Access Technologies
    5. Converting Data Reports to Crystal Reports
    6. Summary
    7. More Information
  15. 13. Working with the Windows API
    1. Type Changes
      1. Changes to Integer and Long Data Types
      2. Changes to Fixed-Length Strings
    2. Variable Type “As Any” Is No Longer Supported
    3. Passing User-Defined Types to API Functions
    4. Changes to “AddressOf” Functionality
    5. Functions ObjPtr, StrPtr, and VarPtr Are No Longer Supported
    6. Moving API Calls to Visual Basic .NET
    7. Summary
    8. More Information
  16. 14. Interop Between Visual Basic 6.0 and Visual Basic .NET
    1. Calling .NET Assemblies from Visual Basic 6.0 Clients
    2. Calling Visual Basic 6.0 Libraries from Visual Basic .NET Clients
    3. How to Achieve Interoperability
      1. Access Requirements
      2. Requirements for Interoperability with COM
      3. Accessing .NET Assemblies Directly from Visual Basic 6.0
      4. Creating Interoperability Wrappers in .NET
      5. Command Line Registration
      6. Data Type Marshaling
        1. Custom Marshaling
      7. Error Management
        1. Catching .NET Exceptions in Visual Basic 6.0
        2. Catching OnError Conditions Raised from Visual Basic 6.0 in Visual Basic .NET
      8. Sinking COM Events
      9. OLE Automation Call Synchronization
    4. Resource Handling
      1. Constructors and Destructors in Visual Basic .NET
      2. Garbage Collection
    5. Summary
    6. More Information
  17. 15. Upgrading MTS and COM+ Applications
    1. Using MTS/COM+ in Visual Basic 6.0
    2. Using COM+ in Visual Basic .NET
    3. General Considerations
      1. COM+ Application Types
      2. Using SOAP Services
        1. SOAP
      3. COM+ Application Proxies in .NET
    4. Upgrading MTS/COM+ Services
      1. COM+ Example Scenario
        1. Upgrading the Server Component
        2. Upgrading the Client Application
      2. COM+ Compensating Resource Manager
        1. Upgrading a Worker Component
        2. Upgrading a Compensator Component
      3. COM+ Object Pooling
      4. COM+ Application Security
      5. COM+ Shared Property Manager
      6. COM+ Object Constructor Strings
        1. Construct Approach
        2. Attribute Approach
      7. COM+ Transactions
    5. Additional COM+ Functionality
    6. COM+ Security
    7. Context Components
    8. COM+ Events
      1. The Event Component
      2. The Event Publisher
      3. The Event Subscriber and Test
        1. Event Interface
        2. Event Class
        3. The Publisher
    9. Message Queuing and Queued Components
    10. Summary
    11. More Information
  18. 16. Application Completion
    1. Separating Assemblies
      1. No Assembly Separation
      2. Separation by Application Tier
      3. Separation by Functionality
    2. Upgrading Integrated Help
      1. Integrating Help at Run Time
      2. Integrating Help at Design Time
      3. Upgrading WinHelp to HTML
      4. Integrating Context-Sensitive Help
    3. Run-time Dependencies
    4. Upgrading Application Setup
      1. Creating a New Installer
      2. Customizing Your Installer
      3. Merge Modules
      4. Web Deployment
      5. COM+ Deployment
        1. Application Proxies
        2. COM+ Installation Packages
        3. Deployment Options
    5. Summary
    6. More Information
  19. 17. Introduction to Application Advancement
    1. Target Audience
    2. Advancing the Architecture, Design, and Implementation
      1. Advancing Architecture
      2. Taking Advantage of Object-Oriented Features
        1. Encapsulation
        2. Inheritance
        3. Interfaces
        4. Polymorphism
        5. Overloading Functionality
        6. Visual Inheritance
      3. Layering Implementation
      4. Design Patterns
        1. Use of Frameworks, Libraries, and Application Blocks
        2. Refactoring to Patterns
      5. Implementation
        1. Replacing API Calls with .NET Framework Intrinsic Functions
        2. Replacing Registry API with .NET Intrinsic Functions
        3. Serialization
        4. Optimizing Performance with .NET Collections
        5. COM Object Creation in Visual Basic .NET
    3. Summary
    4. More Information
  20. 18. Advancements for Common Application Scenarios
    1. Windows Applications and Windows Forms Smart Clients
      1. Architecture Advancements
        1. Intelligent Install and Update
        2. Self-Update and ClickOnce
        3. Client Device Flexibility
      2. Technology Updates
        1. Replacing Resize Logic with Docking and Anchoring
        2. Intrinsic Controls
        3. Providing Visual Feedback with the ErrorProvider Control
        4. FlowLayoutPanel and TableLayoutPanel
        5. Windows XP Look and Feel
        6. Localization and Resources
        7. Resource Files
        8. ToolTips
      3. Business Components (Enterprise Services)
        1. Advancing the Application Architecture
          1. Using Enterprise Services and Attributes
          2. Self-Describing Components
        2. Technology Updates
          1. Working with Threads
          2. Working with Transactions
          3. Performance
          4. Queuing
          5. Security in COM+
          6. Load Balancing
          7. COM+ Events
    2. Summary
    3. More Information
  21. 19. Advancements for Common Web Scenarios
    1. Web Applications and ASP.NET
      1. Architectural Advancements
      2. Master Pages
      3. HTTP Modules
        1. Configuring HTTP Modules
        2. Creating HTTP Modules
    2. Web Services
      1. Web Services Benefits
      2. Architecture Advancements
        1. Service Interfaces
        2. Web Service Discovery
      3. Creating a Web Service
      4. Consuming a Web Service
      5. Technology Updates
        1. Web Services Enhancements (WSE)
          1. Web Services Security
          2. Attachments
          3. WS-Routing
    3. Summary
    4. More Information
  22. 20. Common Technology Scenarios
    1. Application Security
      1. Using Identities and Authentication
      2. Using Cryptography
    2. Application Manageability
      1. Using Configuration Files
      2. Using Deployment and Update Features
      3. Using Performance Counters
      4. Using Tracing and Logging
    3. Application Performance and Scalability
      1. Exception Handling Considerations
      2. String Handling Considerations
      3. Database Access Considerations
      4. Multithreading and the BackgroundWorker Component
      5. Caching
    4. Communication and State Management
      1. Moving From DCOM to HTTP
        1. Using Marshaling
        2. Creating Web Proxies
        3. Using Service Agents
      2. Replacing Message Queuing with System.Messaging
    5. Upgrading ODBC and OLE DB Data Access Components
      1. The ODBC .NET Data Provider
      2. The OLE DB .NET Data Provider
      3. Accessing Oracle Databases from the .NET Framework
        1. The .NET Framework Data Provider for Oracle
    6. Upgrading ADO to ADO.NET
      1. ADO.NET Overview
        1. Differences Between ADO and ADO.NET
      2. ADO vs. ADO.NET Components
        1. Upgrading ADODB.Connection
        2. Upgrading ADODB.Command
        3. Upgrading ADODB.Parameter
        4. Upgrading ADODB.Recordset
    7. Summary
    8. More Information
  23. 21. Testing Upgraded Applications
    1. Fitch & Mather Stocks 2000
    2. Test Objectives
    3. Testing Process
      1. Create Test Plan and Test Code
      2. Create Test Environment
      3. Review the Design
      4. Review of Code
      5. Performing Unit Testing – White Box Testing
      6. Black Box Testing
      7. White Box Testing – Profiling
    4. An Overview of Test Strategies
      1. Test Strategy Based on the Waterfall Methodology
      2. Test Strategy Based on the Iterative Methodology
    5. Test Strategy Based on the Agile Methodology
    6. Tools for Testing Visual Basic .NET Applications
      1. NUnit
      2. FxCop
      3. Application Center Test (ACT)
      4. Visual Studio Analyzer
      5. Trace and Debug Classes
      6. TraceContext Class
      7. CLR Profiler
      8. Enterprise Instrumentation Framework (EIF)
      9. Performance Counters
    7. Summary
    8. More Information
  24. A. References to Related Topics
    1. Visual Basic 6.0 Resource Center
    2. Coding Standards
    3. Choosing File I/O Options
    4. More Information
  25. B. Application Blocks, Frameworks, and Other Development Aids
    1. Using Visual Basic .NET Application Blocks
    2. Building “My” Facades
    3. Building Visual Studio .NET Snippets
    4. Mobile Applications and the .NET Compact Framework
      1. Microsoft Mobile Technology Overview
      2. Overview of the .NET Compact Framework
        1. Included Components
        2. Removed Features
        3. Default Project Settings
      3. Porting from eMbedded Visual Basic
      4. Creating a Mobile Version of a Desktop Application
        1. Porting the User Interface
        2. The Porting Process
      5. Synchronizing with Server Applications
    5. More Information
      1. Footnotes
  26. C. Introduction to Upgrading ASP
    1. Process Overview
      1. Preparing the Application
      2. Upgrading the Application
      3. Testing and Debugging the Upgraded Application
    2. Understanding the ASP to ASP.NET Migration Assistant
      1. Tasks Performed by the Migration Assistant
      2. Limitations of the Migration Assistant
    3. Preparing the Application
      1. Preparing the Environment
        1. System Resources
        2. Third-Party Components
        3. IIS and Virtual Directories
        4. Tools
      2. Preparing Your Code for the Migration Assistant
        1. Register All Referenced COM Components
        2. Verify Compilation
        3. Remove Circular References
        4. Avoid Mixing Scripting Languages on the Server Side
    4. Upgrading the Application
      1. Upgrade Options
      2. Using the ASP to ASP.NET Migration Assistant
        1. Using the Wizard
        2. Using the Command Line Tool
      3. Completing the Upgrade with Manual Changes
    5. Testing and Debugging the Upgraded Application
    6. Deployment
    7. More Information
  27. D. Upgrading FMStocks 2000 — A Case Study
    1. About FMStocks 2000
      1. Reasons FMStocks 2000 Is Used for the Case Study
      2. FMStocks 2000 Setup
      3. FMStocks_AutomatedUpgrade Setup
      4. FMStocks_NET Setup
    2. FMStocks 2000 Assessment and Analysis
      1. Overview of the Structure of FMStocks
      2. Overview of the Use Cases
      3. Obtaining the Upgrade Inventory
      4. Obtaining Source Code Metrics
      5. Handling of Unsupported Features
      6. Determining Application Dependencies
    3. Upgrading FMStocks 2000
      1. Planning the Upgrade
        1. Deciding the Upgrade Strategy
        2. Defining the Upgrade Order
        3. Creating the Upgrade Schedule
      2. Preparing the Application
      3. Executing Automated Upgrade
        1. Visual Basic 6.0 to Visual Basic .NET Using the Upgrade Wizard
        2. ASP to ASP.NET Using the Migration Assistant
      4. Applying Manual Upgrade Adjustments
      5. Functional Testing
        1. Interface Not Upgraded Correctly
        2. Request Changed to Response During Upgrade
        3. Exception While Passing Parameter Using ByRef
        4. Type Format Exception for Recordset
        5. Response.Cookies.Item(“Account”).Value
        6. Err.Number 5 Occurred When Redirecting to Another ASPX Page
    4. Summary
    5. More Information
  28. Inside Front Cover
    1. Additional Resources for Visual Basic Developers