You are previewing Visual Basic® .NET Unleashed.
O'Reilly logo
Visual Basic® .NET Unleashed

Book Description

Visual Basic.NET Unleashed is a complete book on the fundamentals of programming with a fully object-oriented language filled with new idioms and capabilities. In addition to the fundamentals, this book covers:

  • Free threading and multithreading

  • Inheritance

  • Virtual methods and shared methods

  • Structured exception handling

  • Event handling

  • Encapsulation at the namespace level

  • Web Services

  • .NET Framework compatibility

  • Table of Contents

    1. Copyright
    2. About the Author
    3. Acknowledgments
    4. Tell Us What You Think!
    5. Introduction
    6. Introducing Visual Basic .NET
      1. Using the Unified Visual Studio IDE
        1. User-Customizable Profiles
        2. Creating a Project
        3. Building Projects
        4. The Code Behind the Form
        5. Configuring IDE Options
        6. Debugging in the New IDE
        7. An Overview of Project Templates
        8. IntelliSense
        9. Using Views
        10. Documentation
        11. Summary
      2. Out with the Old, In with the New
        1. File Extensions
        2. Namespaces
        3. References
        4. Option Statements
        5. Data Types
        6. Variable Declarations
        7. Operators
        8. Type Conversion Functions
        9. Variable Scope Changes in VB .NET
        10. Flow Control Statements
        11. Arrays and Collections
        12. Structured Exception Handling
        13. Visual Basic .NET Handling of Reserved Words
        14. Compatibility Between VB6 and VB .NET
        15. Summary
      3. Basic Programming in Visual Basic .NET
        1. Declaring and Initializing Variables
        2. Working with Block-Level Scope
        3. Static Variables
        4. Using Static Variables
        5. Using Arrays
        6. Working with New Abstract Data Types
        7. Shadow Variables
        8. Functions and Subroutines
        9. Defining Structures
        10. Using Objects
        11. Exception Handling
        12. Summary
      4. Macros and Visual Studio Extensibility
        1. Automating Repetitive Tasks
        2. Using the Macro Explorer
        3. Exporting the Macro
        4. Using the Macro IDE
        5. Creating a Macro Project
        6. Managing Visual Studio from the Command Window
        7. Responding to IDE Events
        8. Customizing Visual Studio
        9. Creating Add-Ins
        10. Creating Wizards
        11. Visual Studio Integration Program (VSIP)
        12. Summary
      5. Subroutines, Functions, and Structures
        1. Writing Procedures
        2. Defining Procedure Arguments
        3. Working with Recursion
        4. Defining Structures
        5. Using Enumerated Types
        6. Summary
    7. Advanced Object-Oriented Programming
      1. Reflection
        1. Reflection Namespace
        2. Emitting Types at Runtime Using Reflection
        3. Other Places Reflection Is Used
        4. Localization
        5. Summary
      2. Creating Classes
        1. Defining Classes
        2. Encapsulation and Information Hiding
        3. Adding Field and Property Members
        4. Adding Methods to Classes
        5. Adding Class Events
        6. Defining Nested Classes
        7. Creating Instances of a Class
        8. Summary
      3. Adding Events
        1. Understanding Events and Event Handlers
        2. Creating Event Handlers in the Windows Form Designer
        3. Creating Event Handlers in the Code Editor
        4. Creating Runtime Event Handlers
        5. Creating Event Handlers in the WebForms Designer
        6. Declaring and Raising Events
        7. Summary
      4. Understanding Delegates
        1. Using the EventHandler Delegate
        2. Reviewing Delegate Members
        3. Defining Delegates
        4. Passing Delegates as Arguments
        5. Multicasting Delegates
        6. Using Delegates Across Project Boundaries
        7. Summary
      5. Inheritance and Polymorphism
        1. Inheritance Basics
        2. What Is Inheritance?
        3. Defining Classes That Must Be Subclassed
        4. Defining Classes That Cannot Be Subclassed
        5. Polymorphism
        6. Dynamic Typecasting
        7. Defining Interfaces
        8. Summary
      6. Shared Members
        1. Declaring Shared Fields
        2. Defining Shared Properties
        3. Using Shared Methods
        4. Defining Shared Constructors
        5. Implementing Factory Methods
        6. Overloading Shared Members
        7. Raising Shared Events
        8. Summary
      7. Defining Attributes
        1. Understanding the Role of Attributes
        2. Annotating Types and Members
        3. Viewing Attributes with the MSIL Disassembler
        4. Extracting Attributes Using Reflection
        5. Creating Custom Attributes
        6. Component Attributes
        7. COM Interop Attributes
        8. Summary
    8. User Interface Design
      1. Creating a Console Application
        1. Console Application Basics
        2. Using the Console Class
        3. Defining the FileSort Demo
        4. Console Application Namespaces
        5. Multithreading a Console Application
        6. Debugging Console Applications
        7. Keeping Track of the File System
        8. Summary
      2. Multithreaded Applications
        1. Asynchronous Processing without Threads
        2. Lightweight Threading with Thread Pools
        3. Heavyweight Threading
        4. Applying the ThreadStatic Attribute
        5. Multithreading in Windows Forms
        6. Summary
      3. Using Windows Forms
        1. Reviewing the Forms Namespace
        2. Reviewing the System.Drawing Namespace
        3. Using the Form Class
        4. Custom Form Painting with GDI+
        5. Summary
      4. Designing User Interfaces
        1. Managing Control Layout
        2. Working with Menus
        3. Advanced Form Techniques
        4. What Do the Component and Control Classes Do for Us?
        5. Adding Controls Dynamically
        6. Creating Custom UserControls
        7. Creating Custom Controls
        8. Summary
      5. Programming with GDI+
        1. GDI+ Basics
        2. Advanced Drawing
        3. Custom Drawing in Windows Forms
        4. Graphics Printing
        5. Summary
    9. Building Web Services
      1. Using and Implementing Web Services
        1. Web Services in Review
        2. Finding Web Services with UDDI
        3. Calling Web Services
        4. Implementing Web Services
        5. Choosing Web Access Methods
        6. Managing State Information
        7. Handling and Throwing Exceptions in Web Services
        8. Debugging Web Services
        9. Compiling and Deploying Web Projects
        10. Summary
      2. ASP.NET Web Programming
        1. Web Forms
        2. Using Request and Response
        3. ASP.NET and ADO.NET
        4. Output Caching
        5. Performance Considerations
        6. Rendering Controls
        7. Dynamically Adding Controls to a Page
        8. Creating Custom Web Controls
        9. Summary
      3. Writing to the Event Log
        1. Managing an Event Source
        2. Writing Events to an Existing Log
        3. Writing to a Custom Event Log
        4. Getting the Contents of an Event Log
        5. Clearing an Event Log
        6. Receiving Event Notifications
        7. Using a Remote Event Log
        8. Using EventLogTraceListener
        9. Summary
      4. VB6 Programming Element Changes in VB .NET
        1. Discontinued Programming Elements
        2. Declaration and Grammar Changes
        3. Variable Scope Changes
        4. Changes to Procedure Declarations
        5. Changes to Properties
        6. Changes to Array Bounds
        7. Changes to Data Types
        8. Changes to Operators
        9. Changes to Flow Control
        10. Changes to Classes and Interfaces
        11. Replaced Programming Elements
        12. Programming Elements Supported Differently
        13. Replace Variant with Object
      5. Bibliography