VISUAL BASIC 2012 PROGRAMMER S REFERENCE

Transcription

1

2

3 VISUAL BASIC 2012 PROGRAMMER S REFERENCE INTRODUCTION xxvii PART I IDE CHAPTER 1 Introduction to the IDE CHAPTER 2 Menus, Toolbars, and Windows CHAPTER 3 Windows Forms Designer CHAPTER 4 WPF Designer CHAPTER 5 Visual Basic Code Editor CHAPTER 6 Debugging PART II GETTING STARTED CHAPTER 7 Selecting Windows Forms Controls CHAPTER 8 Using Windows Forms Controls CHAPTER 9 Windows Forms CHAPTER 10 Selecting WPF Controls CHAPTER 11 Using WPF Controls CHAPTER 12 WPF Windows CHAPTER 13 Program and Module Structure CHAPTER 14 Data Types, Variables, and Constants CHAPTER 15 Operators CHAPTER 16 Subroutines and Functions CHAPTER 17 Program Control Statements CHAPTER 18 Error Handling CHAPTER 19 Database Controls and Objects CHAPTER 20 LINQ CHAPTER 21 Metro-Style Applications

4 PART III OBJECT-ORIENTED PROGRAMMING CHAPTER 22 OOP Concepts CHAPTER 23 Classes and Structures CHAPTER 24 Namespaces CHAPTER 25 Collection Classes CHAPTER 26 Generics PART IV INTERACTING WITH THE ENVIRONMENT CHAPTER 27 Printing CHAPTER 28 Confi guration and Resources CHAPTER 29 Streams CHAPTER 30 Filesystem Objects PART V APPENDICES APPENDIX A Useful Control Properties, Methods, and Events APPENDIX B Variable Declarations and Data Types APPENDIX C Operators APPENDIX D Subroutine and Function Declarations APPENDIX E Control Statements APPENDIX F Error Handling APPENDIX G Windows Forms Controls and Components APPENDIX H WPF Controls APPENDIX I Visual Basic Power Packs APPENDIX J Form Objects APPENDIX K Classes and Structures APPENDIX L LINQ APPENDIX M Generics APPENDIX N Graphics APPENDIX O Useful Exception Classes APPENDIX P Date and Time Format Specifiers

5 APPENDIX Q Other Format Specifiers APPENDIX R The Application Class APPENDIX S The My Namespace APPENDIX T Streams APPENDIX U Filesystem Classes APPENDIX V Visual Studio Versions INDEX

6

7 Visual Basic 2012 PROGRAMMER S REFERENCE Rod Stephens John Wiley & Sons, Inc.

8 Visual Basic 2012 Programmer s Reference Published by John Wiley & Sons, Inc Crosspoint Boulevard Indianapolis, IN Copyright 2012 by John Wiley & Sons, Inc., Indianapolis, Indiana Published simultaneously in Canada ISBN: ISBN: (ebk) ISBN: (ebk) ISBN: (ebk) Manufactured in the United States of America No part of this publication may be reproduced, stored in a retrieval system or transmitted in any form or by any means, electronic, mechanical, photocopying, recording, scanning or otherwise, except as permitted under Sections 107 or 108 of the 1976 United States Copyright Act, without either the prior written permission of the Publisher, or authorization through payment of the appropriate per-copy fee to the Copyright Clearance Center, 222 Rosewood Drive, Danvers, MA 01923, (978) , fax (978) Requests to the Publisher for permission should be addressed to the Permissions Department, John Wiley & Sons, Inc., 111 River Street, Hoboken, NJ 07030, (201) , fax (201) , or online at Limit of Liability/Disclaimer of Warranty: The publisher and the author make no representations or warranties with respect to the accuracy or completeness of the contents of this work and specifically disclaim all warranties, including without limitation warranties of fitness for a particular purpose. No warranty may be created or extended by sales or promotional materials. The advice and strategies contained herein may not be suitable for every situation. This work is sold with the understanding that the publisher is not engaged in rendering legal, accounting, or other professional services. If professional assistance is required, the services of a competent professional person should be sought. Neither the publisher nor the author shall be liable for damages arising herefrom. The fact that an organization or Web site is referred to in this work as a citation and/or a potential source of further information does not mean that the author or the publisher endorses the information the organization or Web site may provide or recommendations it may make. Further, readers should be aware that Internet Web sites listed in this work may have changed or disappeared between when this work was written and when it is read. For general information on our other products and services please contact our Customer Care Department within the United States at (877) , outside the United States at (317) or fax (317) Wiley publishes in a variety of print and electronic formats and by print-on-demand. Some material included with standard print versions of this book may not be included in e-books or in print-on-demand. If this book refers to media such as a CD or DVD that is not included in the version you purchased, you may download this material at For more information about Wiley products, visit Library of Congress Control Number: Trademarks: Wiley, the Wiley logo, Wrox, the Wrox logo, Wrox Programmer to Programmer, and related trade dress are trademarks or registered trademarks of John Wiley & Sons, Inc. and/or its affiliates, in the United States and other countries, and may not be used without written permission. Visual Basic is a registered trademark of Microsoft Corporation. All other trademarks are the property of their respective owners. John Wiley & Sons, Inc., is not associated with any product or vendor mentioned in this book.

9 ABOUT THE AUTHOR ROD STEPHENS started out as a mathematician, but while studying at MIT, he discovered how much fun programming is and has been programming professionally ever since. During his career, he has worked on an eclectic assortment of applications in such fields as telephone switching, billing, repair dispatching, tax processing, wastewater treatment, concert ticket sales, cartography, and training for professional football players. Rod is a Microsoft Visual Basic Most Valuable Professional (MVP) and has taught introductory programming at ITT Technical Institute. He has written more than two dozen books that have been translated into languages from all over the world, and more than 250 magazine articles covering Visual Basic, C#, Visual Basic for Applications, Delphi, and Java. Rod s popular VB Helper website ( receives several million hits per month and contains thousands of pages of tips, tricks, and example programs for Visual Basic programmers, as well as example code for this book. His C# Helper website ( contains similar material for C# programmers. You can contact Rod at RodStephens@csharphelper.com or RodStephens@vb-helper.com. ABOUT THE TECHNICAL EDITOR BRIAN HOCHGURTEL has been doing.net development for over ten years, and actually started his.net experience with Rod Stephens when they wrote the Wiley book Visual Basic.NET and XML together in Currently Brian works as a SharePoint Developer and Administrator for a large defense contractor in Colorado.

10 CREDITS Executive Editor Robert Elliott Senior Project Editor Adaobi Obi Tulton Technical Editor Brian Hochgurtel Production Editor Daniel Scribner Copy Editor Kim Cofer Editorial Manager Mary Beth Wakefi eld Freelancer Editorial Manager Rosemarie Graham Associate Director of Marketing David Mayhew Marketing Manager Ashley Zurcher Business Manager Amy Knies Production Manager Tim Tate Vice President and Executive Group Publisher Richard Swadley Vice President and Executive Publisher Neil Edde Associate Publisher Jim Minatel Project Coordinator, Cover Katie Crocker Proofreader Nicole Hirschman Indexer Ron Strauss Cover Designer Ryan Sneed Cover Image Erik Isakson / Tetra Images / JupiterImages

11 ACKNOWLEDGMENTS THANKS TO BOB ELLIOTT, Adaobi Obi Tulton, Sydney Jones, Rayna Erlick, Kim Cofer, Daniel Scribner, and all of the others who worked so hard to make this book possible. Thanks also to Brian Hochgurtel for giving me another perspective and the benefit of his valuable experience.

12

13 CONTENTS INTRODUCTION xxvii PART I: IDE CHAPTER 1: INTRODUCTION TO THE IDE 3 Introducing the IDE 3 Different IDE Appearances 4 IDE Configurations 5 Projects and Solutions 6 Starting the IDE 6 Creating a Project 8 Saving a Project 11 Summary 13 CHAPTER 2: MENUS, TOOLBARS, AND WINDOWS 15 IDE Tools 15 Menus 16 File 16 Edit 18 View 19 Project 20 Build 24 Debug 24 Data 24 Format 25 Tools 25 Test 28 Window 28 Help 29 Toolbars 30 Secondary Windows 30 Toolbox 32 Properties Window 33 Summary 33

14 CONTENTS CHAPTER 3: WINDOWS FORMS DESIGNER 35 Introducing Windows Forms Designer 35 Setting Designer Options 35 Adding Controls 37 Selecting Controls 38 Copying Controls 39 Moving and Sizing Controls 40 Arranging Controls 40 Setting Properties 40 Setting Group Properties 41 Using Smart Tags 41 Adding Code to Controls 42 Summary 43 CHAPTER 4: WPF DESIGNER 45 Introducing WPF Designer 45 Editor Weaknesses 46 Recognizing Designer Windows 47 Adding Controls 48 Selecting Controls 49 Moving and Sizing Controls 50 Setting Properties 51 Setting Group Properties 51 Adding Code to Controls 52 Summary 53 CHAPTER 5: VISUAL BASIC CODE EDITOR 55 Editing Code 55 Margin Icons 56 Outlining 58 Tooltips 59 IntelliSense 60 Code Coloring and Highlighting 61 Code Snippets 63 Architectural Tools 64 Rename 64 Go To Defi nition 64 Go To Type Defi nition 64 Highlight References 65 Find All References 65 Generate From Usage 65 xii

15 CONTENTS The Code Editor at Run Time 66 Summary 68 CHAPTER 6: DEBUGGING 69 Debugging and Testing 69 The Debug Menu 70 The Debug Windows Submenu 72 The Breakpoints Window 74 The Command and Immediate Windows 75 Summary 77 PART II: GETTING STARTED CHAPTER 7: SELECTING WINDOWS FORMS CONTROLS 81 Controls 81 Controls Overview 82 Choosing Controls 86 Containing and Arranging Controls 87 Making Selections 89 Entering Data 90 Displaying Data 90 Providing Feedback 91 Initiating Action 92 Displaying Graphics 94 Displaying Dialog Boxes 94 Third-Party Controls 95 Summary 96 CHAPTER 8: USING WINDOWS FORMS CONTROLS 97 Using Controls and Components 97 Controls and Components 98 Creating Controls 99 Properties 101 Properties at Design Time 101 Properties at Run Time 104 Useful Control Properties 106 Position and Size Properties 109 Methods 110 Events 110 xiii

16 CONTENTS Creating Event Handlers at Design Time 111 Validation Events 112 Summary 114 CHAPTER 9: WINDOWS FORMS 115 Using Forms 115 Transparency 116 About, Splash, and Login Forms 117 Mouse Cursors 118 Icons 120 Application Icons 121 Notification Icons 121 Properties Adopted by Child Controls 122 Property Reset Methods 123 Overriding WndProc 123 MRU Lists 125 Dialog Boxes 126 Wizards 128 Summary 129 CHAPTER 10: SELECTING WPF CONTROLS 131 WPF Controls and Code 131 Controls Overview 132 Containing and Arranging Controls 133 Making Selections 136 Entering Data 137 Displaying Data 137 Providing Feedback 138 Initiating Action 138 Presenting Graphics and Media 139 Providing Navigation 140 Managing Documents 140 Digital Ink 141 Summary 142 CHAPTER 11: USING WPF CONTROLS 143 WPF Controls 143 WPF Concepts 144 Separation of User Interface and Code 144 WPF Control Hierarchies 145 xiv

17 CONTENTS WPF in the IDE 145 Editing XAML 146 Editing Visual Basic Code 147 XAML Features 148 Objects 148 Resources 151 Styles 152 Templates 153 Transformations 156 Animations 156 Drawing Objects 159 Procedural WPF 162 Documents 166 Flow Documents 166 Fixed Documents 168 XPS Documents 169 Summary 169 CHAPTER 12: WPF WINDOWS 171 Using WPF Windows 171 Window Applications 172 Page Applications 174 Browser Applications 174 Frame Applications 176 Summary 177 CHAPTER 13: PROGRAM AND MODULE STRUCTURE 179 Solutions and Projects 179 Hidden Files 180 Code File Structure 184 Code Regions 185 Conditional Compilation 186 Namespaces 193 Typographic Code Elements 195 Comments 195 XML Comments 195 Line Continuation 198 Implicit Line Continuation 199 Line Joining 200 Summary 200 xv

18 CONTENTS CHAPTER 14: DATA TYPES, VARIABLES, AND CONSTANTS 203 Variables 203 Data Types 204 Type Characters 207 Data Type Conversion 210 Narrowing Conversions 210 Data Type Parsing Methods 212 Widening Conversions 213 The Convert Class 213 ToString 213 Variable Declarations 214 Attribute_List 214 Accessibility 215 Shared 216 Shadows 216 ReadOnly 219 Dim 219 WithEvents 220 Name 221 Bounds_List 222 New 223 As Type and Inferred Types 224 Initialization_Expression 225 Initializing Collections 228 Multiple Variable Declarations 229 Option Explicit and Option Strict 230 Scope 233 Block Scope 233 Procedure Scope 234 Module Scope 234 Namespace Scope 235 Restricting Scope 235 Parameter Declarations 236 Property Procedures 238 Enumerated Data Types 240 Anonymous Types 243 Nullable Types 244 Constants 244 Accessibility 245 As Type 245 Initialization_Expression 246 xvi

19 CONTENTS Delegates 246 Naming Conventions 248 Summary 249 CHAPTER 15: OPERATORS 251 Understanding Operators 251 Arithmetic Operators 252 Concatenation Operators 253 Comparison Operators 253 Logical Operators 255 Bitwise Operators 257 Operator Precedence 257 Assignment Operators 259 The StringBuilder Class 260 Date and TimeSpan Operations 261 Operator Overloading 262 Summary 266 CHAPTER 16: SUBROUTINES AND FUNCTIONS 267 Managing Code 267 Subroutines 268 Attribute_List 268 Inheritance_Mode 272 Accessibility 273 Subroutine_Name 274 Parameters 274 Implements interface.subroutine 279 Statements 281 Functions 281 Property Procedures 283 Extension Methods 284 Lambda Functions 285 Relaxed Delegates 287 Asynchronous Methods 290 Calling EndInvoke Directly 291 Handling a Callback 293 Using Async and Await 295 Summary 297 xvii

20 CONTENTS CHAPTER 17: PROGRAM CONTROL STATEMENTS 299 Controlling Programs 299 Decision Statements 299 Single-Line If Then 300 Multiline If Then 300 Select Case 301 Enumerated Values 304 IIf 304 If 306 Choose 306 Looping Statements 308 For Next 308 Non-Integer For Next Loops 311 For Each 311 Enumerators 314 Iterators 316 Do Loop Statements 316 While End 318 Summary 318 CHAPTER 18: ERROR HANDLING 321 The Struggle for Perfection 321 Bugs versus Unplanned Conditions 322 Catching Bugs 323 Catching Unplanned Conditions 324 Global Exception Handling 326 Structured Error Handling 328 Exception Objects 330 Throwing Exceptions 331 Re-throwing Exceptions 333 Custom Exceptions 334 Debugging 335 Summary 336 CHAPTER 19: DATABASE CONTROLS AND OBJECTS 337 Data Sources 337 Automatically Connecting to Data 338 Connecting to the Data Source 338 Adding Data Controls to the Form 341 Automatically Created Objects 344 xviii

21 CONTENTS Other Data Objects 345 Data Overview 346 Connection Objects 347 Transaction Objects 350 Data Adapters 352 Command Objects 356 DataSet 358 DataTable 360 DataRow 363 DataColumn 365 DataRelation 366 Constraints 368 DataView 370 DataRowView 373 Simple Data Binding 373 CurrencyManager 374 Complex Data Binding 377 Summary 379 CHAPTER 20: LINQ 381 The Many Faces of LINQ 381 Introduction to LINQ 383 Basic LINQ Query Syntax 384 From 385 Where 386 Order By 386 Select 387 Using LINQ Results 389 Advanced LINQ Query Syntax 390 Join 390 Group By 391 Aggregate Functions 393 Set Operations 394 Limiting Results 394 LINQ Functions 395 LINQ Extension Methods 397 Method-Based Queries 397 Method-Based Queries with Lambda Functions 399 Extending LINQ 401 LINQ to Objects 403 LINQ to XML 404 XML Literals 404 xix

22 CONTENTS LINQ into XML 405 LINQ out of XML 406 LINQ to ADO.NET 409 LINQ to SQL and LINQ to Entities 409 LINQ to DataSet 410 PLINQ 413 Summary 414 CHAPTER 21: METRO-STYLE APPLICATIONS 417 Building Metro-Style Applications 417 Starting a New Project 418 Special Image Files 419 Building MetroBones 420 Control Layout 421 XAML Code 421 Zooming in on the Controls 424 Visual Basic Code 424 Testing 428 Summary 429 PART III: OBJECT-ORIENTED PROGRAMMING CHAPTER 22: OOP CONCEPTS 433 Introducing OOP 433 Classes 434 Encapsulation 436 Inheritance 437 Inheritance Hierarchies 438 Refi nement and Abstraction 438 Has-a and Is-a Relationships 441 Adding and Modifying Class Features 441 Interface Inheritance 443 Polymorphism 444 Method Overloading 445 Extension Methods 446 Summary 447 CHAPTER 23: CLASSES AND STRUCTURES 449 Packaging Data 449 Classes 450 xx

23 CONTENTS Attribute_list 450 Partial 451 Accessibility 452 Shadows 453 Inheritance 454 Implements interface 456 Structures 456 Structures Cannot Inherit 457 Structures Are Value Types 457 Memory Required 457 Heap and Stack Performance 459 Object Assignment 459 Parameter Passing 460 Boxing and Unboxing 461 Class Instantiation Details 461 Structure Instantiation Details 464 Garbage Collection 466 Finalize 467 Dispose 469 Constants, Properties, and Methods 471 Events 473 Declaring Events 473 Raising Events 474 Catching Events 475 Shared Variables 477 Shared Methods 477 Summary 479 CHAPTER 24: NAMESPACES 481 Handling Name Conflicts 481 The Imports Statement 482 Automatic Imports 484 Namespace Aliases 486 Namespace Elements 486 The Root Namespace 487 Making Namespaces 487 Classes, Structures, and Modules 488 Resolving Namespaces 489 Summary 492 xxi

24 CONTENTS CHAPTER 25: COLLECTION CLASSES 493 Grouping Data 493 What Is a Collection? 494 Arrays 494 Array Dimensions 496 Lower Bounds 497 Resizing 497 Speed 498 Other Array Class Features 498 Collections 499 ArrayList 499 StringCollection 501 NameValueCollection 501 Dictionaries 503 ListDictionary 503 Hashtable 504 HybridDictionary 505 StringDictionary 505 SortedList 505 CollectionsUtil 505 Stacks and Queues 506 Stack 506 Queue 508 Generics 509 Collection Initializers 511 Iterators 512 Summary 513 CHAPTER 26: GENERICS 515 Class Creators 515 Advantages of Generics 516 Defining Generics 516 Generic Constructors 517 Multiple Types 518 Constrained Types 520 Instantiating Generic Classes 521 Imports Aliases 522 Derived Classes 523 Generic Collection Classes 523 Generic Methods 524 xxii

25 CONTENTS Generics and Extension Methods 524 Summary 526 PART IV: INTERACTING WITH THE ENVIRONMENT CHAPTER 27: PRINTING 529 Printing Concepts 529 Basic Printing 530 Drawing Basics 534 Graphics Objects 534 Pens 536 Brushes 538 A Booklet Example 540 Summary 545 CHAPTER 28: CONFIGURATION AND RESOURCES 547 The Need for Configuration 547 My 548 Me and My 549 My Sections 549 Environment 550 Setting Environment Variables 550 Using Environ 551 Using System.Environment 551 Registry 553 Native Visual Basic Registry Methods 554 My.Computer.Registry 556 Configuration Files 559 Resource Files 562 Application Resources 562 Using Application Resources 563 Embedded Resources 564 Localization Resources 564 Application 566 Application Properties 566 Application Methods 567 Application Events 568 Summary 569 xxiii

26 CONTENTS CHAPTER 29: STREAMS 571 Stream Concepts 571 Stream 572 FileStream 574 MemoryStream 575 BinaryReader and BinaryWriter 576 TextReader and TextWriter 578 StringReader and StringWriter 579 StreamReader and StreamWriter 580 OpenText, CreateText, and AppendText 581 Custom Stream Classes 582 Summary 583 CHAPTER 30: FILESYSTEM OBJECTS 585 Programming Approaches 585 Permissions 586 Visual Basic Methods 586 File Methods 586 File System Methods 588 Sequential-File Access 589 Random-File Access 589 Binary-File Access 592.NET Framework Classes 592 Directory 592 File 594 DriveInfo 595 DirectoryInfo 596 FileInfo 598 FileSystemWatcher 600 Path 602 My.Computer.FileSystem 604 My.Computer.FileSystem.SpecialDirectories 606 Summary 606 PART V: APPENDICES APPENDIX A: USEFUL CONTROL PROPERTIES, METHODS, AND EVENTS 611 APPENDIX B: VARIABLE DECLARATIONS AND DATA TYPES 619 xxiv APPENDIX C: OPERATORS 629

27 CONTENTS APPENDIX D: SUBROUTINE AND FUNCTION DECLARATIONS 637 APPENDIX E: CONTROL STATEMENTS 641 APPENDIX F: ERROR HANDLING 647 APPENDIX G: WINDOWS FORMS CONTROLS AND COMPONENTS 649 APPENDIX H: WPF CONTROLS 657 APPENDIX I: VISUAL BASIC POWER PACKS 665 APPENDIX J: FORM OBJECTS 669 APPENDIX K: CLASSES AND STRUCTURES 681 APPENDIX L: LINQ 685 APPENDIX M: GENERICS 695 APPENDIX N: GRAPHICS 699 APPENDIX O: USEFUL EXCEPTION CLASSES 711 APPENDIX P: DATE AND TIME FORMAT SPECIFIERS 715 APPENDIX Q: OTHER FORMAT SPECIFIERS 719 APPENDIX R: THE APPLICATION CLASS 725 APPENDIX S: THE MY NAMESPACE 729 APPENDIX T: STREAMS 747 APPENDIX U: FILESYSTEM CLASSES 755 APPENDIX V: VISUAL STUDIO VERSIONS 771 INDEX 773 xxv

28

29 INTRODUCTION IT HAS BEEN SAID THAT SIR ISAAC NEWTON was the last person to know everything. He was an accomplished physicist (his three laws of motion were the basis of classical mechanics, which defi ned astrophysics for three centuries), mathematician (he was one of the inventors of calculus and developed Newton s Method for finding roots of equations), astronomer, natural philosopher, and alchemist (okay, maybe the last one was a mistake). He invented the reflecting telescope, a theory of color, and a law of cooling, and he studied the speed of sound. Just as important, he was born before relativity, quantum mechanics, gene sequencing, thermodynamics, parallel computation, and a swarm of other extremely difficult branches of science. If you ever used Visual Basic 3, you too could have known everything. Visual Basic 3 was a reasonably small but powerful language. Visual Basic 4 added classes to the language and made Visual Basic much more complicated. Versions 4, 5, and 6 added more support for database programming and other topics such as custom controls, but Visual Basic was still a fairly understandable language, and if you took the time you could become an expert in just about all of it. Visual Basic.NET changed the language in much more fundamental ways and made it much harder to understand every last detail of Visual Basic. The.NET Framework added powerful new tools to Visual Basic, but those tools came at the cost of increased complexity. Associated technologies have been added to the language at an ever-increasing rate, so today it is impossible for anyone to be an expert on every topic that deals with Visual Basic. To cover every nook and cranny in Visual Basic you would need an in-depth understanding of database technologies, custom controls, custom property editors, XML, cryptography, serialization, two- and three-dimensional graphics, multi-threading, reflection, the code document object model (DOM), diagnostics, globalization, web services, inter-process communication, work flow, Office, ASP, Windows Forms, WPF, and much more. This book doesn t even attempt to cover all of these topics. Instead, it provides a broad, solid understanding of essential Visual Basic topics. It explains the powerful development environment that makes Visual Basic such a productive language. It describes the Visual Basic language itself and explains how to use it to perform a host of important development tasks. It also explains the forms, windows, controls, and other objects that Visual Basic provides for building applications in a modern windowing environment. This book may not cover every possible topic related to Visual Basic, but it does cover the majority of the technologies that developers need to build sophisticated applications.

30 INTRODUCTION SHOULD YOU USE VISUAL BASIC 2012? Software engineers talk about five generations of languages (so far). A first-generation language (1GL) is machine language: 0s and 1s. For example, the binary command might mean to combine the register CL with the value at address 12H by using the exclusive-or (XOR) operation. Pretty incomprehensible, right? You actually had to program some early computers by painstakingly toggling switches to enter 0s and 1s! A second-generation language (2GL) is an assembly language that provides terse mnemonics for machine instructions. It provides few additional tools beyond an easier way to write machine code. In assembly language, the previous XOR command might look like XOR CL, [12H]. It s a lot better than assembly language but it s still pretty hard to read. Third-generation languages (3GLs) are higher-level languages such as Pascal and FORTRAN. They provide much more sophisticated language elements such as subroutines, loops, and data structures. In Visual Basic, the previous example might look something like total = total Xor value. WHERE DID THE REGISTER GO? Higher-level languages generally don t directly use registers or memory addresses. Instead they work with variables with names such as total and value. The language s compiler automatically figures out when a value should be placed in a register or other location. Fourth-generation languages (4GLs) are natural languages, such as SQL. They let developers use a language that is sort of similar to a human language to execute programming tasks. For example, the SQL statement SELECT * FROM Customers WHERE Balance > 50 tells the database to return information about customers who owe more than $50. Fifth-generation languages (5GLs) provide powerful, highly graphical development environments to allow developers to use the underlying language in more sophisticated ways. The emphasis is more on the development environment than on the language itself. The Visual Studio development environment is an extremely powerful fifth-generation tool. It provides graphical editors to make building forms and editing properties easy and intuitive; IntelliSense to help developers remember what to type next; auto-completion so developers can use meaningful variable names without needing to waste time typing them completely by hand; tools that show call hierarchies indicating which routines call which others; and breakpoints, watches, and other advanced debugging tools that make building applications easier. Visual Studio is so powerful that the answer to the question of whether you should use it is practically obvious: If you want to write powerful applications that run in a Windows operating system, you should use Visual Studio. Visual Basic is not the only language that uses Visual Studio. The C# language does, too, so now the question is, should you use Visual Basic or C#? xxviii