Learning Visual Basic .NET

Learning Visual Basic .NET......Page 2
About This Book......Page 3
Who This Book Is For......Page 4
How the Book Is Organized......Page 5
Conventions Used in This Book......Page 8
Support......Page 9
We'd Like to Hear from You......Page 10
Acknowledgments......Page 12
1.1. Visual Basic and .NET......Page 13
1.1.1. Stepchild No Longer......Page 14
1.2. The .NET Platform......Page 16
1.3. The .NET Framework......Page 18
1.4. The VB.NET Language......Page 19
1.5. The Structure of VB.NET Applications......Page 21
1.6. The Development Environment......Page 23
2. Getting Started with VB.NET......Page 24
2.1. What's in a Program?......Page 27
2.2. Your First Program: Hello World......Page 29
2.2.1. The Compiler......Page 30
2.3.1. Line-by-Line Analysis......Page 32
3. Object-Oriented Programming......Page 37
3.1. Creating Models......Page 39
3.2. Classes and Objects......Page 41
3.3. Defining a Class......Page 43
3.4. Class Relationships......Page 46
3.5. The Three Pillars of Object-Oriented Programming......Page 47
3.6. Encapsulation......Page 49
3.7. Specialization......Page 51
3.8. Polymorphism......Page 52
3.9. Object-Oriented Analysis and Design......Page 53
4. Visual Studio .NET......Page 56
4.1. Start Page......Page 59
4.1.1. Projects and Solutions......Page 60
4.1.2. Templates......Page 61
4.2.1. Layout......Page 64
4.3. IntelliSense......Page 68
4.4. Building and Running......Page 70
4.5. For More Information......Page 71
5.1. Types......Page 72
5.1.1. Numeric Types......Page 75
5.1.2. Non-Numeric Types: Boolean, Char, Date, and String......Page 76
5.1.3. Types and Compiler Errors......Page 77
5.2.1. Specifying Type with a Character......Page 80
5.2.2. Initializing Variables......Page 82
5.2.3. Default Values......Page 84
5.3.1. Literal Constants......Page 86
5.3.2. Symbolic Constants......Page 88
5.3.3. Enumerations......Page 91
5.3.4. About Casting......Page 95
5.4. Strings......Page 99
5.5. Statements......Page 100
5.6. Whitespace......Page 102
6. Branching......Page 104
6.1. Unconditional Branching Statements......Page 105
6.2.1. If Statements......Page 109
6.2.2. If . . . Else Statements......Page 112
6.2.3. Nested If Statements......Page 113
6.2.4. ElseIf......Page 114
6.2.5. Select Case Statements......Page 115
6.3.1. Creating Loops with Goto......Page 120
6.3.2. The Do Loop......Page 122
6.3.3. Breaking out of a Do Loop......Page 126
6.3.4. The For Loop......Page 128
6.3.5. Controlling a For Loop Using Next......Page 131
7.1. The Assignment Operator (=)......Page 134
7.2.1. Simple Arithmetical Operators (+, -, *, /, \)......Page 135
7.2.2. The modulus Operator (Mod) to Return Remainders......Page 139
7.2.3. The Exponentiation Operator (^)......Page 141
7.3. Relational Operators......Page 142
7.4. Logical Operators Within Conditionals......Page 145
7.5. Operator Precedence......Page 148
8. Classes and Objects......Page 152
8.1. Defining Classes......Page 154
8.1.1. Instantiating Objects......Page 155
8.1.2. Modules Are Classes......Page 158
8.1.3. Memory Allocation: The Stack Versus the Heap......Page 160
8.1.4. Creating a Time Class......Page 166
8.1.5. Access Modifiers......Page 169
8.2. Method Arguments......Page 172
8.3. Constructors......Page 175
8.4. Initializers......Page 179
8.5. Copy Constructors......Page 181
8.6. The Me Keyword......Page 183
8.7. Using Shared Members......Page 185
8.8. Destroying Objects......Page 189
9.1. Overloading Methods......Page 191
9.2. Encapsulating Data with Properties......Page 196
9.2.2. The Set Accessor......Page 200
9.2.3. ReadOnly and WriteOnly Properties......Page 201
9.3.1. Passing Arguments by Value......Page 203
9.3.2. Passing Arguments by Reference......Page 205
9.3.3. Passing Reference Types by Value......Page 206
10.1. Setting a Breakpoint......Page 210
10.1.1. Using the Debug Menu to Set Your Breakpoint......Page 215
10.1.2. Examining Values: The Autos and Locals Windows......Page 216
10.1.3. Set Your Watch......Page 218
10.2. The Call Stack......Page 221
11.1. Specialization and Generalization......Page 223
11.2.1. Implementing Inheritance......Page 228
11.2.2. Calling Base Class Constructors......Page 230
11.2.4. Controlling Access......Page 231
11.3.1. Creating Polymorphic Types......Page 233
11.3.2. Creating Polymorphic Methods......Page 234
11.3.3. Versioning with Overridable and Overrides......Page 239
11.4. Abstract Classes......Page 242
11.5. NotInheritable Classes......Page 246
11.6. The Root of All Classes: Object......Page 247
11.7.1. Boxing Is Implicit......Page 251
11.7.2. Unboxing Must Be Explicit......Page 252
12. Structures......Page 254
12.1. Defining a Structure......Page 255
12.1.3. Public Member Data?......Page 260
13. Interfaces......Page 262
13.1. Defining an Interface......Page 264
13.2. Implementing an Interface......Page 266
13.3. Implementing More Than One Interface......Page 271
13.4. Casting to an Interface......Page 274
13.4.1. The Is Operator......Page 276
13.5. Extending Interfaces......Page 280
13.6. Combining Interfaces......Page 285
13.7. Overriding Interface Implementations......Page 287
14. Arrays......Page 293
14.1.1. Declaring Arrays......Page 294
14.1.2. The Size of the Array......Page 295
14.1.3. The ReDim Keyword......Page 296
14.1.4. Understanding Default Values......Page 297
14.1.5. Accessing Array Elements......Page 299
14.1.6. The For Each Statement......Page 302
14.1.7. Initializing Array Elements......Page 304
14.1.8. The ParamArray Keyword......Page 306
14.2. Multidimensional Arrays......Page 310
14.2.1. Rectangular Arrays......Page 311
14.2.2. Jagged Arrays......Page 315
14.3. System.Array......Page 320
14.4. Indexers and the Default Property......Page 325
14.4.1. Default Properties and Assignment......Page 330
14.4.2. Indexing on Other Values......Page 331
15.1. The Collection Interfaces......Page 336
15.1.1. The IEnumerable Interface......Page 338
15.1.2. Walking Through the For Each Loop in a Debugger......Page 349
15.2. Array Lists......Page 353
15.3. The Collection Class......Page 358
15.4. Queues......Page 362
15.5. Stacks......Page 368
15.6. Copying from a Collection Type to an Array......Page 373
16.1. Creating Strings......Page 377
16.1.3. Strings Are Immutable......Page 379
16.2. Manipulating Strings......Page 381
16.2.1. Comparing Strings......Page 383
16.2.2. Concatenating Strings......Page 385
16.2.3. Copying Strings......Page 386
16.2.4. Testing for Equality......Page 388
16.2.5. Other Useful String Methods......Page 389
16.2.6. Finding Substrings......Page 392
16.2.7. Splitting Strings......Page 395
16.2.8. The StringBuilder Class......Page 398
16.3. Regular Expressions......Page 403
16.4. The Regex Class......Page 405
17. Throwing and Catching Exceptions......Page 408
17.1. Throwing Exceptions......Page 410
17.2. Searching for an Exception Handler......Page 411
17.3. The Throw Statement......Page 413
17.4. The Try and Catch Statements......Page 415
17.5. How the Call Stack Works......Page 418
17.6. Creating Dedicated Catch Statements......Page 421
17.7. The Finally Statement......Page 424
17.8. Exception Class Methods and Properties......Page 427
17.9. Custom Exceptions......Page 431
18.1. Creating a Windows Application......Page 434
18.2. Events......Page 441
18.2.1. Web Applications......Page 446
18.3. Server-Side Code......Page 450
19.1. Where to Go from Here......Page 452
19.2. Advanced Topics in VB.NET......Page 453
19.3. Web (ASP.NET) Programming......Page 456
19.4. Windows Forms Programming......Page 457
19.5. Other Resources......Page 458
Colophon......Page 459