Visual Basic.NET and the.net Platform: An Advanced Guide

Transcription

1 Visual Basic.NET and the.net Platform: An Advanced Guide ANDREWTROELSEN APress Media, LLC

2 Visual Basic.NET and the.net Platform: An Advanced Guide Copyright 2002 by Andrew'Ii'oelsen Originally published by Apress in 2002 All rights reserved. No part of this work may be reproduced or transmitted in any form or by any means, electronic or mechanical, including photocopying, recording, or by any information storage or retrieval system, without the prior written permission of the copyright owner and the publisher. ISBN ISBN (ebook) DOI / Trademarked names may appear in this book. Rather than use a trademark symbol with every occurrence of a trademarked name, we use the names only in an editorial fashion and to the benefit of the trademark owner, with no intention of infringement of the trademark. Editorial Directors: Dan Appleman, Gary Cornell, Jason Gilmore, Karen Watterson Technical Reviewers: Pamela Fanstill, Rob Macdonald, Dan Appleman, William Oellermann Managing Editor: Grace Wong Copy Editors: Anne Friedman, Nicole LeClerc Production Editors: Janet Vail with Kari Brooks and Anne Friedman Composition and Art Services: Impressions Book and Journal Services, Inc. Indexer: Carol Burbo Cover Designer: Tom Debolski Marketing Manager: Stephanie Rodriguez Distributed to the book trade in the United States by Springer-Verlag New York, lnc.,175 Fifth Avenue, New York, NY, and outside the United States by Springer-Verlag GmbH & Co. KG, Tiergartenstr. 17, Heidelberg, Germany In the United States, phone SPRINGER, orders@springer-ny. com, or visit http: I lwww. springer-ny. com. Outside the United States, fax , orders@springer. de, or visit http: I lwww. springer. de. For information on translations, please contact Apress directly at 901 Grayson Street, Suite 204, Berkeley, CA Phone , fax: , info@apress.com, or visit The information in this book is distributed on an "as is" basis, without warranty. Although every precaution has been taken in the preparation of this work, neither the author nor Apress shall have any liability to any person or entity with respect to any loss or damage caused or alleged to be caused directly or indirectly by the information contained in this work. The source code for this book is available to readers at http: I lwww. a press. com in the Downloads section. You will need to answer questions pertaining to this book in order to successfully download the code.

3 This book is dedicated to the memory of the thousands of people who lost their lives during the tragic events that took place on September 11, Of exactly equal importance, this book is dedicated to each and every individual who worked around the clock, without limits, to bring some degree of normalcy back to New York, Pennsylvania, and Washington D. C. Thank you for your strength, inspiration, and relentless commitment. Thank you for engaging the unimaginable.

4 Contents at a Glance What You Need to Use This Book.... xv Acknowledgments.... xxii Introduction.... xviii Chapter 1 The Philosophy of NET Chapter 2 Building Visual Basic NET Applications Chapter 3 VB.NET Language Fundamentals Chapter 4 Object-Oriented Programming with VB.NET Chapter 5 Interfaces and Collections Chapter 6 Delegates, Events, and Callback Interfaces Chapter 1 Assemblies, Threads, and AppDomains Chapter 8 Type Reflection and Attribute-Based Programming Chapter 9 Building a Better Window (Introducing Windows Forms) Chapter 10 A Better Painting Framework (GDI+) Chapter 11 Programming with Windows Form Controls Chapter 12 Input, Output, and Object Serialization Chapter 13 Interacting with Unmanaged Code Chapter 14 Data Access with ADO.NET Chapter 15 Web Development and ASP. NET Chapter 16 Building (and Understanding) Web Services Index iv

5 Contents What You Need to Use This Book.... xv Acknowledgments.... xxii Introduction.... xviii Chapter 1 The Philosophy of NET Understanding the Current State of Affairs The NET Solution Building Blocks of.net (CLR, CTS, and CLS)... 6.NET -Aware Programming Languages... 7 What VB NET Brings to the Table... 9 An Overview of.net Binaries (aka Assemblies) The Role of Microsoft Intermediate Language The Role of Metadata Compiling IL to Platform-Specific Instructions NET Types and NET Names paces Understanding the Common Language Runtime Understanding the Common Type System Understanding the Common Language Specification Working with Namespaces A Tour of the NET Name spaces Referencing External Assemblies Increasing Your Namespace Nomenclature Summary Chapter 2 Building Visual Basic.NET Applications Building VB.NET Applications Using the Command Line Compiler Building Your First VB.NET Application v

6 Contents Building VB.NET Applications Using the Visual Studio NET IDE Building Your VS.NET Test Application Configuring a VB.NET Project The Properties Window Adding Some Code What Happened to the World of VB 6.0? Upgrading VB 6.0 Projects into VB.NET The Microsoft.VisualBasic.Compatability.VB6 Namespace Should You Upgrade? Summary Chapter 3 VB NET Language Fundamentals The Role of the Module Type The Main Method Data Types and Variable Declarations Experimenting with the System Data Types Data Type Conversions Concatenation Operators Basic Input and Output with the Console Class Introducing VB NET String Formatting Anatomy of a Simple VB. NET Class Creating Objects: Constructor Basics Default Values Defining Program Constants Understanding Value Types and Reference Types The Master Node: System.Object VB NET Iteration Constructs VB.NET Control Flow Constructs Additional VB.NET Operators Defining Custom Class Methods Method Parameter Modifiers (ByRef and ByVal) Shared Methods Static (Not Shared) Data Array Manipulation in VB NET String Manipulation in VB.NET VB.NET Enumerations Defining Structures in VB NET Defining Custom Namespaces Summary vi

7 Contents Chapter 4 Object-Oriented Programming with VB. NET A Catalog of VB NET 00-Centric Keywords Formal Definition of the VB.NET Class Member Overloading Defining the Default Public Interface Pillars of OOP The First Pillar: VB.NET's Encapsulation Services Pseudo-Encapsulation: Creating Read-Only Fields The Second Pillar: VB.NET's Inheritance Support Keeping Family Secrets: The "Protected" Keyword Nested Type Definitions The Third Pillar: VB NET's Polymorphic Support Casting between Class Types {CType) Exception Handling Understanding Object Lifetime Finalizing an Object Reference Building an Ad Hoc Destruction Method Interacting with the Garbage Collector Summary Chapter 5 Interfaces and Collections Understanding Interface-Based Programming Building a Custom Enumerator {!Enumerable and!enumerator) Building Cloneable Objects {ICloneable) Building Comparable Objects {!Comparable) Exploring the System.Collections Namespace Summary Chapter 6 Delegates, Events, and Callback Interfaces A Quick Recap of Events a la VB Designing an Event Interface The VB. NET Delegate Keyword The Simplest Possible Example Building a More Elaborate Delegate Example vii

8 Contents Understanding (and Using) Events Summary Problems with Classic COM Binaries An Overview of NET Assemblies Building a Single File Test Assembly A VB. NET Client Application A C# Client Application Cross-Language Inheritance Exploring the CarLibrary' s Manifest Exploring the CarLibrary' s Types Building Multi file Assemblies Understanding Private Assemblies Probing Basics Understanding Shared Assemblies Understanding Shared Names Using a Shared Assembly Understanding. NET Version Policies Recording Version Information Building SharedAssembly Version Specifying Custom Version Policies Using the.net Administrative Tool (mscorcfg.msc) The Ngen.exe Utility Review of Traditional Win32 Thread Programming Understanding System.AppDomain System. Threading Names pace Naming Threads Concurrency Revisited The VB.NET "Sync Lock" Keyword Using System. Threading. Interlocked Summary Chapter 8 Type Reflection and Attribute-Based Programming Understanding Reflection The System. Type Class Investigating the System. Reflection Names pace Dynamically Loading an Assembly Understanding Dynamic Invocation (Late Binding) Understanding (and Building) Dynamic Assemblies Understanding Attributed Programming viii

9 Contents Building Custom Attributes The VB.NET "Assemblyinfo.vb" File Discovering Attributes at Runtime Summary Chapter 9 Building a Better Window (Introducing Windows Forms) A Tale of Two GUI Names paces Overview of the Windows Forms Names pace Building a Windows Forms Application by Hand Building a Visual Studio.NET Windows Forms Project Workspace The System. Windows. Forms. Application Class The Anatomy of a Form Basic Form Functionality The System. ComponentModel. Component Class The Control Class Control Events Responding to Keyboard Events The Control Class Revisited The ScrollableControl Class ContainerControl Class The Form Class Building Menus with Windows Forms Building Your Menu System Building a Menu Using Visual Studio NET Understanding Status Bars Building a Status Bar Using Visual Studio NET Building a ToolBar Building ToolBars at Design Time A Minimal and Complete Windows Forms Application Interacting with the System Registry Interacting with the Event Viewer Building an MDI Application Summary ix

10 Contents Chapter 10 A Better Painting Framework (GDI+) Remembering the World of VB 6.0 Graphics Programming Survey of the GDI+ Namespaces Overview of the System.Drawing Namespace Configuring a GDI+ Project Workspace Examining the System.Drawing Utility Types Understanding Paint Sessions Understanding the Graphics Class Default GDI+ Coordinate System Establishing an Active Color Manipulating Fonts Survey of the System. Drawing. Drawing2D Names pace Working with Pens Rendering Images Dragging, Hit Testing, and the PictureBox Control Understanding the NET Resource Format System. Resources Names pace Working with ResourceWriters Working with ResourceManagers Automatic Resource Configuration ala Visual Studio.NET Summary Chapter 11 Programming with Windows Form Controls Understanding the Windows Forms Control Hierarchy Adding Controls to Forms (the Hard Way) Adding Controls to Forms {the Easy Way) The TextBox Control The Mighty Button Type (and the ButtonBase Parent Class) Working with CheckBoxes Working with RadioButtons and GroupBoxes ListBoxes and ComboBoxes Configuring the Tab Order The TrackBar Control The MonthCalendar Control More on the System.DateTime Type The Spin Controls: DomainUpDown and NumericUpDown Working with Panel Controls Assigning Tool Tips to Controls X

11 Contents Working with the ErrorProvider Configuring a Control's Anchoring Behavior Configuring a Control's Docking Behavior Building Custom Dialog Boxes Form Inheritance Understanding Custom Controls The Class, Control, UserControl, and Component Distinction Building a Custom UserControl Creating the Images Building the Design Time GUI Establishing the Default Public Sector Defining the Custom Events Supporting Custom Properties Controlling the Animation Building a VB NET Client Application Select Members of the System.ComponentModel Namespace Enhancing the Design Time Appearance of CarControl Building a.net (Data) Component Connecting to the Cars Database Using Your Custom Component Summary Chapter 12 Input, Output, and Object Serialization Exploring the System. IO Namespace The Directory(Info) and File(Info) Types Enumerating Files with the Directoryinfo Type Creating Subdirectories with the Directoryinfo Type The Shared Members of the Directory Class The Fileinfo Class The Abstract Stream Class Working with StreamWri ters and StreamReaders Working with StringWri ters Working with StringReaders Working with Binary Data (BinaryReaders and BinaryWriters) Object Persistence in the.net Framework The Role of Object Graphs Configuring Objects for Serialization Serialization Using a Binary Formatter Serialization Using a SOAP Formatter xi

12 Contents Custom Serialization (and the ISerializable Interface) A Windows Forms Car Logger Application Summary Chapter 13 Interacting with Unmanaged Code Understanding Interoperabili ty Issues A Painfully Simple Example: VB.NET Applications Communicating with VB 6.0 COM Types The System. Runtime. InteropServices Namespace Understanding.NET to COM Interoperability The Role of COM IDL Importing the Type Library Examining the Generated Assembly Manifest Building a More Interesting VB 6.0 COM Server Examining the Interop Assembly The Complete VB NET Client Understanding COM to. NET Interoperability The Role of the CCW Understanding the ((Class Interface" Building Your NET Type Generating the Type Library and Registering the.net Types Examining the Exported Type Information Viewing the Type Using the OLE/COM Object Viewer Examining the Registration Entries Building a Visual Basic 6.0 Test Client NET to COM Mapping Issues Controlling the Generated IDL (or Influencing Tlbexp.exe) Interacting with COM+ Component Services Building COM+-Aware Types Building a COM+-Aware VB NET Type Examining the Component Services Explorer Summary Chapter 14 Data Access with ADO.NET The Need for ADO. NET Understanding the ADO.NET Namespaces The Types of System. Data Examining the DataColumn Type xii

13 Contents Examining the Data Row Type Details of the Data Table Building a Complete Data Table Understanding the DataView Type Understanding the Role of the DataSet Expressing Relations Using the Data Relation Type Reading and Writing XML-Based DataSets Building a Simple Test Database ADO.NET Managed Providers Working with the OleDb Managed Provider The Role of the OleDbDataAdapter Type Working with the SQL Managed Provider Autogenerated SQL Commands Filling a Multitabled DataSet (and Adding DataRelations) Bring in the Wizards! Summary Chapter 15 Web Development and ASP. NET Web Applications and Web Servers The Basic Structure of an HTML Document Basic HTML Text Formatting Visual Studio '.NET HTML Editors HTML Form Development The Role of Client-Side Scripting Submitting the Form Data (GET and POST) Building a Classic Active Server Page Building Your First Official ASP. NET Application Some Problems with Classic ASP Some Benefits of ASP. NET The ASP. NET Name spaces Creating a Simple VB NET Web Application The Architecture of an ASP.NET Web Application Understanding the Application/Session Distinction The Globals.asax File and HttpApplication Type The Life Cycle of a Page-Derived Type Understanding ViewS tate Debugging and Tracing ASP.NET Applications Understanding the Benefits of Web Form Controls Working with Web Form Controls Categories of Web Form Controls xiii

14 Contents Understanding Server-Side Event Handling A Complete ASP o NET Example Summary Chapter 16 Building (and Understanding) Web Services Understanding the Role of Web Services The Anatomy of a Web Service An Overview of the Web Service Names paces Examining the System o Web o Services Names pace Building a Simple Web Service The WebMethodAttribute Type Understanding the Web Service Description Language {WSDL) Web Service Invocation Protocols WSDL into VB o NET Code (Generating a Proxy) Building the Assembly Building a Client Generating a Proxy with VSoNET A More Interesting Web Service (and Web Client) Serialization of Custom Types (Further Details) Understanding the Discovery Service Protocol Summary Index xiv

15 What Need to This Book You Use THE VERY FIRST THING you must do before you dig in is download the accompanying source code for this book from the Apress Web site (http: I / As you read over each chapter, you find the following icon has been liberally scattered throughout the text: This is your visual cue that the example under discussion may be loaded into Visual Studio.NET for examination. In addition to the source code, you need to have a copy of.net Beta 2. In this text, I have chosen to focus primarily on using the Visual Studio.NET development environment. Although you are free to build and compile your code using nothing more than the VB.NET compiler (which is included with the.net SDK) and Notepad.exe, you will find that VS.NET takes care of a number of low-level details on your behalf. Finally, understand that this is an advanced text geared toward the seasoned software professional. The goals of this text are not to labor over each and every detail of the "For" loop, examine each and every menu selection of the Visual Studio.NET IDE, or describe all ten steps of a given VS.NET wizard. My assumption is that you are well equipped to explore the IDE and have no problem activating menu options. On the other hand, I assume no foreknowledge ofvb.net or the.net platform. In particular, this book is well suited for individuals possessing the following traits: You are an experienced software professional who has solid background in some modern-day programming language (Visual Basic, C++, Java, and so on). You are unafraid to consult online Help, build sample programs, and explore.net on your own terms (and do so often without shame). Even a book of this size cannot possibly cover each and every aspect of the.net platform. The online Help that ships with the.net SDK is incredibly XV

16 What You Need to Use This Book readable, and it provides numerous code examples, white papers, and online tutorials. Once you have read (and understood) these sixteen chapters, you will be in a perfect position to build complete.net solutions with the VB.NET language. At this point, online Help will become your faithful companion that extends and complements the material presented here. So, let's get on with the show! It is my sincere hope that this book will guide you safely through the.net universe and serve as a solid reference during your life as an author of managed code usingvb.net. Andrew Troelsen Minneapolis, Minnesota xvi

17 Acknowledgments FmsT, MANY THANKS to Gary Cornell and Dan Appleman, who encouraged me to translate my first Apress publication ( C# and the.net Platform) into the vernacular ofvisual Basic. A solid (and affectionate) thanks to Grace Wong and Stephanie Rodriguez, who again kept me honest and provided a fantastic working environment (see you at the PDC!). A special thanks to Carol Burbo for working with an incredibly tight deadline in order to index this material. A mammoth amount of gratitude to the editorial staff: Anne Friedman (glad to work with you again Anne! See you on book number three?), Nicole LeClerc, Christie Roden, Janet Vail, and Kari Brooks, who all did an outstanding job editing, formatting, and massaging the knots out of my original manuscript. Thanks for your focus and clarity during the course of this project. I also must offer heartfelt thanks to my primary technical editor, Pam Fanstill. Thanks for laboring over each and every line of syntax and pointing out the lingering C# tokens that escaped my view. Your work was phenomenal (honest). Additional huge thanks are extended to Dan Appleman, Rob Macdonald, and William Oellermann for offering additional technical reviews (and numerous insights). Any remaining faux pas are my sole responsibility. Thanks to my fellow cohorts at Intertech-Inc.: Steve Close, Gina McGhee, Andrew "Gunner" Sondgeroth, and Tom Barnaby, who, while working on their own books, provided an encouraging, intense, and positive environment. As well, thanks to Tom Salonek for just being Tom (remember, always bring more beer). Finally, thanks and love to Mary and Wally Troelsen (aka Mom and Dad), and my wife, friend, and confidant, Amanda. I hope you all know how much your support means to me. xvii

18 Introduction MicRosoFT's.NET PlATFORM represents an entirely new way to build distributed, desktop, and mobile applications. One thing to be painfully aware of from the outset is that the.net platform has nothing at all to do with classic COM, VB 6.0, ATL, or any other pre-.net frameworks. For example, as you read over this text, you will find that.net types do not support!unknown, are not cataloged in the system registry, and are not described using COM type libraries. Understand that these COM primitives have not simply been hidden away from view-they no longer exist. Given that.net is such a radical departure from the current modus operandi ofwin32 development, Microsoft has developed a new language named C# (pronounced "see-sharp") specifically for this new platform. C#, like Java, has its syntactic roots in C++. However, C# has also been influenced by Visual Basic 6.0, specifically with regard to the use of class properties, "for each'' -like iteration, and the IDE itself. Nevertheless, given that C# still uses numerous C++-like tokens (semicolons, colons, and curly brackets), many die-hard VBers may find the syntax of C# a bit unpalatable. The good news is that in addition to the advent of C#, Microsoft has also shipped a brand-new update of the ever-popular Visual Basic programming language termed VB.NET, which is also specifically geared toward the development of.net applications. As you move through this text, you will see that VB.NET is not simply an upgrade from VB 6.0. Rather, VB.NET can best be understood as a brandnew programming language that just happens to look suspiciously like earlier iterations of the language. If you feel this last statement is a bit alarmist in nature, consider the following (partial) sampling of new constructs offered by VB.NET: Unlike VB 6.0, VB.NET supports class constructors, implementation inheritance, classical polymorphism, and method overloading. VB.NET allows developers to natively build multithreaded applications (which could be achieved to some degree in VB 6.0, if you were willing to drop down to the raw Win32 API). Unlike previous versions ofvisual Basic, VB.NET supports the development of extremely robust graphical-based (as opposed to GUI-based) applications using a facility termed GDI+. VB.NET supports new data types (System. Object), removes other data types (the Variant), and has reworked current language constructs (class xviii

19 Introduction properties, strings, arrays, enumerations, and class types) to bring Visual Basic up to snuff with the.net architecture. Despite these (and other) substantial changes, VB.NET still supports the key features that have established Microsoft Visual Basic as the most popular programming language to date. For those of you who have worked with earlier editions ofvb, you will notice many key similarities. On a related note, once you learn the syntax and semantics ofvb.net, you find that the process oflearning additional.net-aware languages (such as C#) is painfully simple. The truth of the matter is that.net is an extremely languageagnostic platform. You can make use of any.net-aware language (and possibly numerous.net-aware languages) during the development of your next coding effort. In this vein, your greatest challenge is not necessarily learning the VB.NET language, but rather coming to terms with the numerous types defined in the.net base class libraries. Once you understand how to leverage the existing code base, you find that the concept of "syntax" becomes a nonissue given that all.net-aware languages make use of the same base class types. This is also a good thing, given that you should be able to move swiftly between various.net languages with minimal fuss and bother. The goals of this text are to provide a solid foundation of the syntax and semantics ofvb.net, as well as the architecture of the.net platform. As you read through the (many) pages that follow, you are exposed to each major facet of the.net base class libraries. Let's take a high-level overview of each chapter. Chapter 1: The Philosophy of.net Chapter 1 functions as the backbone for this text. The first task of the chapter is to examine the world ofwmdows development as we know it today and review the shortcomings of the current state of affairs. However, the primary goal is to acquaint you with the meaning behind a number of.net-centric building blocks, such as the Common Language Runtime (CLR), the Common Type System (CTS), the Common Language Specification (CLS), and the base class libraries. In addition, this chapter introduces you to a set of core tools ULDasm.exe, WmCV.exe, and so on) that allow you to explore the.net class libraries at your leisure. Chapter 2: Building VB.NET Applications Chapter 2 begins with an examination of how to interact with the VB.NET compiler (vbc.exe) in the raw. As you see later in the text, some advanced aspects of VB.NET (such as building multifile assemblies) are only accessible from the xix

20 Introduction command-line compiler. Given this fact, spending the time to build some simple VB.NET applications by hand will serve you well. The later half of this chapter illustrates the core features of the Visual Studio.NET IDE. To wrap things up, you examine the pros and cons of converting existing VB 6.0 code into the.net paradigm. Chapter 3: VB.NET Language Fundamentals The goal of Chapter 3 is to showcase the core syntax of the VB.NET programming language. As you would hope, you are introduced to the intrinsic data types ofvb.net as well as the set of iteration and decision constructs. More important, you learn about the composition of a VB.NET class, and you make friends with a number of new.net techniques, such as value and reference types, namespace development, and the role of the mighty System. Object. Chapter 4: Object-Oriented Programming with VB.NET Now that you can build complex stand-alone types, Chapter 4 focuses on the pillars of object technology: encapsulation, inheritance ("is-a" and "has-a''), and polymorphism (classical and ad hoc). The chapter begins with a high-level examination of these key terms, and then quickly turns its attention to exploring how VB.NET supports each pillar. Along the way, you are exposed to new syntax used to define class properties, and you learn the ins and outs of developing class hierarchies. Finally, this chapter examines a new mechanism to handle runtime anomalies: Structured Exception Handling. The chapter ends with a discussion of the.net garbage collection scheme, and you see how to programmatically interact with this service using the System.GC class type. Chapter s: Interface and Collections Like C++, Java, and VB 6.0, VB.NET supports the technique of interface-based programming. In this chapter you learn the role of an interface and understand how to define and implement such a creature in VB.NET. Once you can build types that support multiple interfaces, you learn a number of techniques you can use to obtain an interface reference from a valid type instance. The second half of this chapter examines a number of predefined interfaces defined within the.net XX

21 Introduction class libraries and illustrates how to make use of the System. Collections namespace to build custom container types. You also learn how to build "cloneable" and "enumerable" types. Chapter 6: Delegates, Events, and Callback Interfaces This chapter rounds out your understanding of core OOP using VB.NET. To begin, you review the classic VB 6.0 event protocol, and you quickly see that VB.NET makes use of the same core keywords (Event, WithEvents, and RaiseEvent) to enable bidirectional communication. Under the hood, however, the.net event architecture is founded on the use of delegates. The bulk of this chapter is spent examining the use of this type and several related topics, such as hooking into events dynamically at runtime using the new AddHandler and RemoveHandler statements. Chapter 7: Assemblies, Threads, and AppDomains At this point you should be very comfortable building stand-alone VB.NET applications. This chapter illustrates how to break apart a monolithic EXE into discrete code libraries. Here, you learn about the internal composition of a.net assembly and understand the distinction between "shared" and "private" assemblies. This entails a discussion of the Global Assembly Cache (GAC), XML configuration files, and side-by-side execution. To further illustrate the virtues of the CLR, this chapter also examines cross-language inheritance using C# and (gasp!) C++. The chapter wraps up with an examination of how to construct multithreaded applications using VB.NET. Chapter 8: Reflection and Attributes Reflection is the process of runtime type discovery. This chapter examines the details behind the System. Reflection namespace and illustrates how to investigate the contents of an assembly on the fly. On a related note, you learn how to build an assembly (and its contained types) at runtime using the System.Reflection.Emit namespace. Chapter 8 also illustrates how to exercise late binding to a.net type and dynamically invoke its members. Finally, the chapter wraps up with a discussion of attribute-based programming. As you will see, this technique allows you to augment compiler-generated metadata with application-specific information. xxi

22 Introduction Chapter 9: Building a Better Window (Introducing Windows Forms) Despite its name, the.net platform has considerable support for building traditional desktop applications. In this chapter, you come to understand how to build a stand-alone main window using the types contained in the System.Windows.Forms namespace. Once you understand the derivation of a Form, you then learn to add support for topmost and pop-up menu systems, toolbars, and status bars. As an added bonus, this chapter also examines how to programmatically manipulate the system registry and Windows 2000 event log. Chapter 10: A Better Painting Framework (GDI+) For the first time in VB's rich ten-year history, programmers are given the tools they need to build exotic, graphics-intensive applications. This chapter teaches you how to render geometric images, bitmaps, and complex textual images onto the Form's client area using VB.NET. On a related note, you learn how to drag images within a Form (in response to mouse movement), as well as how to perform hit tests against geometric regions (in response to mouse clicks). This chapter ends with an examination of the.net resource format which, as you might assume, is based on XML syntax. Chapter 11: Programming with Windows Form Controls This final chapter on Windows Forms examines how to program with the suite of GUI widgets provided by the.net Framework. Here, you discover details behind the Calendar, Data Grid, and input validation controls, in addition to the vanilla-flavored TextBox, Button, and ListBox types (among others). In addition, you learn how to build custom.net controls (and components) using VB.NET. The chapter wraps up with an examination of how to build custom dialog boxes and MDI applications, and you come to understand a new technique termed Form inheritance. Chapter 12: Input, Output, and Object Serialization The.NET Framework provides a number of types devoted to 10 activities. In this chapter you learn how to save and retrieve simple data types to (and from) files, memory locations, and string buffers. Of greater interest is the use of object serialization services. Using a small set of predefined attributes and a corresponding object graph, the Framework is able to persist related objects using an XML or xxii

23 Introduction binary formatter. To illustrate object serialization at work, this chapter wraps up with a Windows Forms application that allows the end user to create and serialize custom class types for use at a later time. Chapter 13: Interacting with Unmanaged Code As bizarre as it may seem, Microsoft's Component Object Model (COM) can now be regarded as a legacy technology. As you most certainly know by this point in the book, the architecture of COM bears little resemblance to that of.net. This chapter examines the details of how COM types and.net types can live together in harmony through the use of COM Callable Wrappers (CCW) and Runtime Callable Wrappers (RCW). Here, you see how various COM constructs such as SAFEARRAYs, COM events, and COM enumerations map into VB.NET code. The chapter concludes by examining how to build.net types that can take advantage of the COM+ runtime. Chapter 14: Data Access with ADO.NET To be perfectly blunt, ADO.NET bears little resemblance to classic ADO proper. As you discover, ADO.NET is a data access model specifically built for the disconnected world. To begin, you learn how to create and populate an in-memory DataSet and establish relationships between the internal Data Tables. The second half of this chapter examines how to make use of the OleDb and Sql managed providers to obtain access to relational database management systems such as Microsoft Access and SQL Server. Once you understand how to connect to a given data store, you learn how to insert, update, and remove data records as well as trigger logic contained within stored procedures. Chapter 15: Web Development and ASP.NET For the sake of completeness, this chapter begins with an overview of the Web programming model and examines how to build Web front ends (using HTML), how to perform client-side validation (using JavaScript), and how to request a response from a classic ASP Web application. Of course, if you are already "Web aware," you are free to skip these initial pages entirely. The bulk of the chapter provides a solid introduction to the ASP.NET architecture. Here, you learn about Web Controls, server-side event handling, and the core properties of the Page type (including the Request and Response properties). As you would hope, you learn how to build a Web-enabled front end that is able to display (and manipulate) data retrieved using ADO.NET. xxiii

24 Introduction Chapter 16: Building (and Understanding} Web Services In this final chapter of this book, you examine the role of.netweb services. Simply put, a "Web service" is a unit of code that is activated using standard HTTP. Here you examine the surrounding technologies (WSDL, SOAP, and discovery services) that enable a Web service to take incoming client requests. Once you understand how to construct a VB.NET Web service, you then learn how to build a client-side proxy class, which hides the low-level SOAP logic from view. xxiv