Visual Basic .NET Programming Language, The

Book description

Praise for The Visual Basic .NET Programming Language

“There is no substitute to getting the inside scoop directly from a book written by the father of a programming language such as Bjarne Stroustrup for C++, James Gosling for Java and Alan Cooper for the original version of Visual Basic. Paul Vick, the father of Visual Basic .NET, explains the whys and hows of this exciting new language better than any other human being on the planet.”

     —Ted Pattison, Barracuda.NET

The Visual Basic .NET Programming Language includes nuances that in all my use and study of VB .NET, I haven’t seen discussed anywhere else. For example, I learned that you can use the Imports statement to import an Enum name, so that you needn’t refer to the enum in all its uses. In addition, I learned that the dictionary lookup operator, ‘!’, works in VB .NET—I thought this one had been retired. In any case, if you’re searching for a book that covers all the language syntax issues, and more, Paul Vick’s book is a great place to look.”

     —Ken Getz, Senior Consultant, MCW Technologies, LLC

“This book is an excellent stepping stone for Visual Basic developers wanting to get their toes wet in the .NET waters. Paul’s presentation of the core topics all VB developers should tackle first is clear, concise, and unlike other books in the genre, does not overwhelm the reader. The VB6 vs. VB.NET task-oriented approach guides you through the new language and OO features, and then moves to basic threading and other CLR topics—as well as to the key points in the COM to .NET transition—in a well thought-out sequence. If you’ve been holding out on VB .NET, this is a great book to get you started.”

     —Klaus H. Probst, Sr. Consultant/Architect, Spherion Technology Services, Microsoft MVP

“There is no shortage of VB .NET books in the market, but this is the only book straight from the creators. While that is an excellent reason in itself for reading this book, it is the brevity and clarity of the content, along with the examples, that makes this book a must-have.”

     —Amit Kalani, Developer

“Overall, I liked this book and it definitely benefited me. I learned new things I didn’t see anywhere else and I’ll certainly put these to good use in the future. Paul’s book makes a great reference manual for intermediate and advanced VB .NET developers.”

     —Philip Williams, System Engineer, LDC Direct

“This book contains a lot of great information I have seen nowhere else and addresses issues that other books do not.”

     —Ethan Roberts, .NET Architect, General Casualty

“This book is full of useful information and provides a good historical background for the Visual Basic .NET Language.”

     —Dave Vitter, Technical Lead Developer and author of Designing Visual Basic .NET Applications (Coriolis, 2001)

The definitive Microsoft Visual Basic .NET reference—authored by Visual Basic .NET’s lead architect

If you want to leverage all of VB .NET’s immense power, get this book. It’s the definitive VB .NET reference and tutorial, and the first Visual Basic book written by one of VB .NET’s lead architects. No other book offers this much behind-the-scenes insight about why VB .NET works the way it does, how it evolved, and how you can make the most of it.

The Visual Basic .NET Programming Language is a superb learning tool for new VB .NET programmers and a must-have reference for developers at every level. Paul Vick presents precise language descriptions, essential reference materials, practical insights, and hundreds of code samples, straight from Microsoft’s VB .NET design team.

Just some of the features include:

  • A history and overview of Visual Basic’s evolution into VB .NET

  • Complete coverage of the language syntax

  • Transitioning from COM to the CLR and leveraging the .NET platform

  • Runtime functions

  • Taking full advantage of VB .NET’s object-oriented features

  • Notes on style, design, and compatibility throughout the text

  • Notes for the advanced user throughout the text

Vick exposes VB .NET’s most powerful capabilities with unprecedented depth and clarity, and packs this book with information you simply won’t find anywhere else. Whether you’re an experienced VB .NET programmer, upgrading from earlier versions of Visual Basic, or coming to Visual Basic and .NET for the first time, you’ll find this book indispensable.

Table of contents

  1. Copyright
    1. Dedication
  2. Praise for The Visual Basic .NET Programming Language
  3. Microsoft .NET Development Series
    1. Titles in the Series
  4. Figures
  5. Tables
  6. Preface
    1. About This Book
      1. A Short, Unofficial History of Visual Basic
    2. Style and Preferences
    3. Acknowledgments
  7. 1. Language Overview
    1. Hello, World!
    2. Fundamental Types
    3. Arrays
    4. Statements
    5. Exception Handling
      1. Structured Exception Handling
      2. Unstructured Exception Handling
    6. Memory Management
    7. Classes, Structures, and Modules
      1. Accessibility
      2. Constructors
      3. Nested Types
    8. Fields
    9. Methods
      1. Parameters
      2. Declare Statements
    10. Properties
    11. Events
      1. Declarative Event Handling
      2. Dynamic Event Handling
    12. Namespaces
    13. Delegates
    14. Inheritance
      1. Protected Access
      2. Overriding
    15. Interfaces
    16. Attributes
    17. Versioning
    18. Conclusion
  8. 2. Basic Concepts
    1. Language Fundamentals
      1. Case Insensitivity
      2. Line Orientation
    2. Declarations and Names
      1. Forward References
    3. Accessibility
    4. The .NET Framework
      1. Program Startup and Termination
    5. Conclusion
  9. 3. Fundamental Types
    1. Boolean
    2. Integer Data Types
      1. Integer Literals
    3. Floating-Point Data Types
      1. Floating-Point Literals
    4. Decimal Data Type
      1. Decimal Literals
    5. Char and String Data Types
      1. Character and String Literals
    6. Date Data Type
      1. Date Literals
    7. Object Data Type
    8. Conversions
      1. Widening and Narrowing Conversions
      2. Supported Conversions
    9. Conclusion
  10. 4. Arrays and Enumerations
    1. Arrays
      1. ReDim and Erase Statements
      2. Array Initializers
      3. Arrays of Arrays
    2. Enumerations
      1. Underlying Types
      2. Conversions
    3. Conclusion
  11. 5. Operators
    1. Precedence
    2. Operator Resolution
    3. Arithmetic Operators
    4. Comparison Operators
    5. Logical and Bitwise Operators
    6. Shift Operators
    7. String Operators
    8. Type Operators
    9. Constant Expressions
    10. Conclusion
  12. 6. Statements
    1. Local Declaration Statements
      1. Type Characters
      2. Initializers
      3. Constants
      4. Static Locals
      5. Implicit Locals
    2. Assignment
    3. With Statement
    4. Conditional Statements
      1. If Statement
      2. Select Statement
    5. Looping Statements
      1. For Statement
      2. For Each Statement
      3. While and Do Statements
      4. Collection Types
    6. Branching Statements
      1. Exit and Return Statements
      2. Goto Statement and Labels
    7. Program Flow Statements
    8. SyncLock
    9. Conclusion
  13. 7. Exceptions
    1. Throwing Exceptions
    2. Structured Exception Handling
      1. Rethrowing Exceptions
    3. Unstructured Exception Handling
      1. Resume and Resume Next
    4. Conclusion
  14. 8. Modules and Namespaces
    1. Modules
    2. Namespaces
      1. Fully Qualified Names
    3. Imports
    4. Preprocessing
      1. Conditional Compilation Statements
      2. Region Statements
    5. Conclusion
  15. 9. Classes and Structures
    1. Memory Management
      1. The Heap and the Stack
    2. Value Types and Structures
    3. Reference Types and Classes
    4. Shared versus Instance
    5. Constructors
      1. Structure Constructors
      2. Shared Constructors
    6. Nested Types
    7. Finalization and Resource Disposal
    8. Conclusion
  16. 10. Methods
    1. Subroutines and Functions
    2. Parameters
      1. Optional Parameters and Parameter Arrays
    3. Method Invocation
      1. Arguments and Reference Parameters
      2. Named Arguments
      3. Late Binding
      4. Conditional Methods
    4. Overloading
      1. Overload Resolution
    5. Declare Statements
      1. Character Translation
      2. String Parameters
    6. Conclusion
  17. 11. Fields and Properties
    1. Fields
      1. Read-Only Fields
    2. Properties
      1. Indexed Properties
      2. Default Properties
      3. Dictionary Lookup
    3. Conclusion
  18. 12. Events and Delegates
    1. Defining and Raising Events
    2. Declarative Event Handling
    3. Handling Events Dynamically
    4. Delegates
      1. Asynchronous Invocation
    5. Delegates and Event Implementation
    6. Conclusion
  19. 13. Inheritance
    1. Protected Accessibility
    2. Conversions
      1. Array Covariance
    3. The .NET Framework Type Hierarchy
      1. DirectCast
    4. Overriding
      1. MyBase and MyClass
    5. Abstract Classes and Methods
    6. Conclusion
  20. 14. Interfaces
    1. Defining Interfaces
    2. Implementing Interfaces
      1. Private Interface Implementation
      2. Event Implementation
    3. Consuming Interfaces
    4. Interface Inheritance
    5. Conclusion
  21. 15. Attributes
    1. Applying Attributes
    2. Defining Attributes
    3. Storing and Reading Attributes
    4. Conclusion
  22. 16. Versioning
    1. Shadowing
      1. Shadowing and Overriding
      2. Shadowing and Accessibility
      3. Default Properties
    2. Overloading
    3. Obsolete
    4. Conclusion
  23. A. Runtime Functions
    1. AppWinStyle Enumeration
    2. CallType Enumeration
    3. Collection Class
    4. ComClassAttribute Attribute
    5. CompareMethod Enumeration
    6. Constants Module
    7. ControlChars Class
    8. Conversion Module
    9. DateAndTime Module
    10. DateFormat Enumeration
    11. DateInterval Enumeration
    12. DueDate Enumeration
    13. ErrObject Class
    14. FileAttribute Enumeration
    15. FileSystem Module
    16. Financial Module
    17. FirstDayOfWeek Enumeration
    18. FirstWeekOfYear Enumeration
    19. Globals Module
    20. Information Module
    21. Interaction Module
    22. MsgBoxResult Enumeration
    23. MsgBoxStyle Enumeration
      1. Button Flags
      2. Icon Flags
      3. Default Button Flags
      4. Message Box Behavior Flags
      5. Miscellaneous Flags
    24. OpenAccess Enumeration
    25. OpenMode Enumeration
    26. OpenShare Enumeration
    27. Strings Module
      1. Format Strings
        1. Predefined Formats
        2. User-Defined Formats
    28. TriState Enumeration
    29. VariantType Enumeration
    30. VbStrConv Enumeration
    31. VBMath Module
    32. VBFixedArrayAttribute Attribute
    33. VBFixedStringAttribute Attribute
  24. B. Making the Transition from COM to the CLR
    1. Type System Additions
      1. Classes
      2. Inheritance
      3. Overloading
      4. Namespaces
    2. Type System Modifications
      1. Arrays
      2. Variant and Object
      3. Structures
      4. Date, Currency, and Decimal
    3. Platform Changes
      1. Deterministic Finalization and Garbage Collection
      2. Let and Set Assignment
      3. Late Binding
      4. On Error and Structured Exception Handling
      5. Events and Delegates
    4. Language Cleanup

Product information

  • Title: Visual Basic .NET Programming Language, The
  • Author(s):
  • Release date: March 2004
  • Publisher(s): Addison-Wesley Professional
  • ISBN: 9780321169518