Learning Visual Basic .NET

Spis treści książki

• Learning Visual Basic .NET
  • SPECIAL OFFER: Upgrade this ebook with OReilly
  • A Note Regarding Supplemental Files
  • Preface
    • About This Book
    • Who This Book Is For
    • How the Book Is Organized
    • Conventions Used in This Book
    • Support
    • Wed Like to Hear from You
    • Acknowledgments
  • 1. Visual Basic .NET and .NET Programming
    • 1.1. Visual Basic and .NET
      • 1.1.1. Stepchild No Longer
    • 1.2. The .NET Platform
    • 1.3. The .NET Framework
    • 1.4. The VB.NET Language
    • 1.5. The Structure of VB.NET Applications
    • 1.6. The Development Environment
  • 2. Getting Started with VB.NET
    • 2.1. What's in a Program?
    • 2.2. Your First Program: Hello World
      • 2.2.1. The Compiler
    • 2.3. Examining Your First Program
      • 2.3.1. Line-by-Line Analysis
  • 3. Object-Oriented Programming
    • 3.1. Creating Models
    • 3.2. Classes and Objects
    • 3.3. Defining a Class
    • 3.4. Class Relationships
    • 3.5. The Three Pillars of Object-Oriented Programming
    • 3.6. Encapsulation
    • 3.7. Specialization
    • 3.8. Polymorphism
    • 3.9. Object-Oriented Analysis and Design
  • 4. Visual Studio .NET
    • 4.1. Start Page
      • 4.1.1. Projects and Solutions
      • 4.1.2. Templates
    • 4.2. Inside the Integrated Development Environment (IDE)
      • 4.2.1. Layout
    • 4.3. IntelliSense
    • 4.4. Building and Running
    • 4.5. For More Information
  • 5. VB.NET Language Fundamentals
    • 5.1. Types
      • 5.1.1. Numeric Types
      • 5.1.2. Non-Numeric Types: Boolean, Char, Date, and String
      • 5.1.3. Types and Compiler Errors
    • 5.2. Variables
      • 5.2.1. Specifying Type with a Character
      • 5.2.2. Initializing Variables
      • 5.2.3. Default Values
    • 5.3. Constants
      • 5.3.1. Literal Constants
      • 5.3.2. Symbolic Constants
      • 5.3.3. Enumerations
      • 5.3.4. About Casting
    • 5.4. Strings
    • 5.5. Statements
    • 5.6. Whitespace
  • 6. Branching
    • 6.1. Unconditional Branching Statements
    • 6.2. Conditional Branching Statements
      • 6.2.1. If Statements
      • 6.2.2. If . . . Else Statements
      • 6.2.3. Nested If Statements
      • 6.2.4. ElseIf
      • 6.2.5. Select Case Statements
    • 6.3. Iteration (Looping) Statements
      • 6.3.1. Creating Loops with Goto
      • 6.3.2. The Do Loop
      • 6.3.3. Breaking out of a Do Loop
      • 6.3.4. The For Loop
      • 6.3.5. Controlling a For Loop Using Next
  • 7. Operators
    • 7.1. The Assignment Operator (=)
    • 7.2. Mathematical Operators
      • 7.2.1. Simple Arithmetical Operators (+, -, *, /, \)
      • 7.2.2. The modulus Operator (Mod) to Return Remainders
      • 7.2.3. The Exponentiation Operator (^)
    • 7.3. Relational Operators
    • 7.4. Logical Operators Within Conditionals
    • 7.5. Operator Precedence
  • 8. Classes and Objects
    • 8.1. Defining Classes
      • 8.1.1. Instantiating Objects
      • 8.1.2. Modules Are Classes
      • 8.1.3. Memory Allocation: The Stack Versus the Heap
      • 8.1.4. Creating a Time Class
      • 8.1.5. Access Modifiers
    • 8.2. Method Arguments
    • 8.3. Constructors
    • 8.4. Initializers
    • 8.5. Copy Constructors
    • 8.6. The Me Keyword
    • 8.7. Using Shared Members
    • 8.8. Destroying Objects
  • 9. Inside Methods
    • 9.1. Overloading Methods
    • 9.2. Encapsulating Data with Properties
      • 9.2.1. The Get Accessor
      • 9.2.2. The Set Accessor
      • 9.2.3. ReadOnly and WriteOnly Properties
    • 9.3. Passing by Value and by Reference
      • 9.3.1. Passing Arguments by Value
      • 9.3.2. Passing Arguments by Reference
      • 9.3.3. Passing Reference Types by Value
  • 10. Basic Debugging
    • 10.1. Setting a Breakpoint
      • 10.1.1. Using the Debug Menu to Set Your Breakpoint
      • 10.1.2. Examining Values: The Autos and Locals Windows
      • 10.1.3. Set Your Watch
    • 10.2. The Call Stack
  • 11. Inheritance and Polymorphism
    • 11.1. Specialization and Generalization
    • 11.2. Inheritance
      • 11.2.1. Implementing Inheritance
      • 11.2.2. Calling Base Class Constructors
      • 11.2.3. Shadowing Base Methods
      • 11.2.4. Controlling Access
    • 11.3. Polymorphism
      • 11.3.1. Creating Polymorphic Types
      • 11.3.2. Creating Polymorphic Methods
      • 11.3.3. Versioning with Overridable and Overrides
    • 11.4. Abstract Classes
    • 11.5. NotInheritable Classes
    • 11.6. The Root of All Classes: Object
    • 11.7. Boxing and Unboxing Types
      • 11.7.1. Boxing Is Implicit
      • 11.7.2. Unboxing Must Be Explicit
  • 12. Structures
    • 12.1. Defining a Structure
      • 12.1.1. No Inheritance
      • 12.1.2. No Initialization
      • 12.1.3. Public Member Data?
  • 13. Interfaces
    • 13.1. Defining an Interface
    • 13.2. Implementing an Interface
    • 13.3. Implementing More Than One Interface
    • 13.4. Casting to an Interface
      • 13.4.1. The Is Operator
    • 13.5. Extending Interfaces
    • 13.6. Combining Interfaces
    • 13.7. Overriding Interface Implementations
  • 14. Arrays
    • 14.1. Arrays
      • 14.1.1. Declaring Arrays
      • 14.1.2. The Size of the Array
      • 14.1.3. The ReDim Keyword
      • 14.1.4. Understanding Default Values
      • 14.1.5. Accessing Array Elements
      • 14.1.6. The For Each Statement
      • 14.1.7. Initializing Array Elements
      • 14.1.8. The ParamArray Keyword
    • 14.2. Multidimensional Arrays
      • 14.2.1. Rectangular Arrays
      • 14.2.2. Jagged Arrays
    • 14.3. System.Array
    • 14.4. Indexers and the Default Property
      • 14.4.1. Default Properties and Assignment
      • 14.4.2. Indexing on Other Values
  • 15. Collection Interfaces and Types
    • 15.1. The Collection Interfaces
      • 15.1.1. The IEnumerable Interface
      • 15.1.2. Walking Through the For Each Loop in a Debugger
    • 15.2. Array Lists
    • 15.3. The Collection Class
    • 15.4. Queues
    • 15.5. Stacks
    • 15.6. Copying from a Collection Type to an Array
  • 16. Strings
    • 16.1. Creating Strings
      • 16.1.1. String Literals
      • 16.1.2. The ToString( ) Method
      • 16.1.3. Strings Are Immutable
    • 16.2. Manipulating Strings
      • 16.2.1. Comparing Strings
      • 16.2.2. Concatenating Strings
      • 16.2.3. Copying Strings
      • 16.2.4. Testing for Equality
      • 16.2.5. Other Useful String Methods
      • 16.2.6. Finding Substrings
      • 16.2.7. Splitting Strings
      • 16.2.8. The StringBuilder Class
    • 16.3. Regular Expressions
    • 16.4. The Regex Class
  • 17. Throwing and Catching Exceptions
    • 17.1. Throwing Exceptions
    • 17.2. Searching for an Exception Handler
    • 17.3. The Throw Statement
    • 17.4. The Try and Catch Statements
    • 17.5. How the Call Stack Works
    • 17.6. Creating Dedicated Catch Statements
    • 17.7. The Finally Statement
    • 17.8. Exception Class Methods and Properties
    • 17.9. Custom Exceptions
  • 18. Applications and Events
    • 18.1. Creating a Windows Application
    • 18.2. Events
      • 18.2.1. Web Applications
    • 18.3. Server-Side Code
  • 19. Afterword
    • 19.1. Where to Go from Here
    • 19.2. Advanced Topics in VB.NET
    • 19.3. Web (ASP.NET) Programming
    • 19.4. Windows Forms Programming
    • 19.5. Other Resources
  • Index
  • About the Author
  • Colophon
  • SPECIAL OFFER: Upgrade this ebook with OReilly

pokaż cały spis treści

ukryj recenzje