Coding Techniques for Microsoft Visual Basic .NET

by Connell, John

• ISBN13: 9780735612549
• ISBN10: 0735612544
• Edition: CD
• Format: Paperback
• Copyright: 2001-11-10
• Publisher: Microsoft Pr

Summary

This unique title goes beyond simply using academic snippets of code to demonstrate a point or language construct to teach Visual Basic.Net. Designed for the beginning, self-taught, or even experienced programmers who are switching to Microsoft Visual Basic.Net from other languages, this book provides insights.

Author Biography

John Connell is CIO and senior vice president with BankFinancial in Chicago, where he and his team develop applications with Visual Basic .NET and other Microsoft tools and technologies. He has a master's degree in computer science, plus an MBA. John teaches graduate-level programming classes at DePaul University in Chicago

Table of Contents

Acknowledgments	xv
Introduction	xvii
Visual Basic .NET from the Ground Up	1	(48)
What a Long, Strange Trip It's Been	2	(6)
From COM to .NET	4	(2)
The .NET World	6	(2)
Why You Need to Learn Visual Basic .NET	8	(1)
What Are the Pieces and How Do They Fit Together? A .NET Framework Overview	9	(7)
Web Services	11	(1)
User Interface	11	(1)
Data and XML	12	(1)
Base Class Library	12	(1)
Common Language Runtime	13	(2)
Where Do We Start to Access Functionality from Visual Basic .NET Source Code?	15	(1)
Visual Basic .NET Is Object Oriented	16	(2)
A Brief Look at How the Visual Basic .NET Language Works	18	(2)
How Is a Visual Basic .NET Program Put Together?	20	(3)
Metadata---Data About Data	20	(1)
The Just-In-Time Compiler	21	(1)
Execution of Visual Basic .NET Code	22	(1)
Assemble the Troops	23	(1)
Configuring the Interactive Development Environment	23	(2)
A First Look at the Visual Basic .NET IDE	25	(16)
Some Visual Basic .NET Code	27	(6)
Files Created by the IDE for Our First .NET Program	33	(5)
Another Word on Assemblies	38	(3)
A Closer Look at the Code	41	(7)
You Mean I Get an Inheritance?	41	(1)
Starting Up Our Form 1 Class	42	(4)
Warning! Don't Fiddle with the Designer's Code	46	(1)
The Big Event	47	(1)
Nothing but .NET	48	(1)
Object-Oriented Programming in Visual Basic .NET	49	(60)
An Object Lesson	49	(1)
Starting Out with Objects	50	(6)
A Class Is Really Only a Blueprint	50	(1)
Let's Talk Objects	51	(1)
Our Form as an Object	52	(2)
Reading, Writing, Invoking	54	(2)
Inheritance	56	(13)
Understanding Namespaces	58	(4)
Inheriting from System.Windows.Forms.Form: Forms and Controls	62	(1)
A Word About Visual Basic .NET Controls	63	(2)
Check Out the Code	65	(2)
The Code Added for the Button	67	(2)
Enough Talk: Press F5 and Run Your Program	69	(7)
The Doppelganger Program: Creating Clones of the Form 1 Class	70	(1)
Important Object Concepts from the Doppelganger Program	71	(5)
Using the Class View to Spy on Structure and Access Modifiers	76	(3)
More About Access Types	78	(1)
Overloading Methods	79	(4)
Some of the Overloaded Show Methods	81	(2)
Polymorphism	83	(1)
What's Controlling Our Form When We Run It?	84	(2)
Try This Out	84	(2)
Your First Real Visual Basic .NET Program	86	(19)
Telling the Application Object Which Form to Run	88	(2)
Let's Add Some Controls	90	(4)
Examining the Handiwork of the IDE-Generated Code	94	(4)
How Do We Hardwire the Controls?	98	(1)
Can You Name That Namespace?	98	(1)
Date and Time Arithmetic	99	(2)
Formatting the Date and Time	101	(2)
Let's Run This Baby!	103	(2)
Conclusion	105	(4)
Writing Your First Class	109	(34)
Creating the Employee Class	110	(17)
Examining the Class Code	113	(5)
Our Class's Namespace	118	(1)
Declaring Our Class	118	(2)
Using Shared Variables	120	(1)
Class Constructors	120	(1)
Overloading Constructors	121	(1)
MyBase.New	122	(1)
Assigning Values to Our Private Data Fields	123	(1)
Overriding	124	(2)
#Region	126	(1)
The Employee Class Properties	127	(3)
More About Inheritance	130	(4)
Virtual Methods	134	(1)
Synchronizing the Class View	134	(2)
Creating Instances of the Employee Class	136	(4)
Conclusion	140	(3)
Visual Basic .NET Data Types and Features	143	(20)
Getting to Know Data Types	143	(1)
Visual Basic .NET Data Types	144	(4)
Value Types	145	(2)
Reference Types	147	(1)
Data Type Features	148	(12)
The System.Object Class	149	(3)
Strong Typing	152	(1)
Type Safety	152	(5)
Data Widening	157	(3)
Garbage Collection: Getting Rid of Our Objects	160	(1)
The Stack and the Managed Heap	160	(1)
Conclusion	161	(2)
Examining the .NET Class Framework Using Files and Strings	163	(28)
What Exactly Is the .NET Framework?	164	(5)
Tapping into the .NET Framework	165	(1)
It All Starts with the System Namespace	165	(4)
Learning to Find and Use What You Need	169	(2)
Searching in Windows Class Viewer	170	(1)
Using the Namespaces	171	(1)
Examining the File Class	171	(2)
Streams	173	(2)
What's the Difference Between a File and a Stream?	174	(1)
Reading and Writing Binary, Numeric, or Text Data	174	(1)
Using the File and StreamWriter Classes in the .NET Framework	175	(8)
Reading Our File	176	(1)
The FileInfo Class	177	(2)
Creating a New File	179	(1)
Enumerating Directory Entries Using the Framework	180	(3)
Let's Talk Strings	183	(7)
What's New in Strings?	184	(1)
Uninitialized Strings	184	(1)
Working with Strings	185	(2)
Copying and Cloning a String	187	(3)
Conclusion	190	(1)
Arrays and Collections in Visual Basic .NET	191	(64)
Building Your First Visual Basic .NET Array	192	(15)
Array Boundaries	194	(4)
Why Arrays Are Based on the System.Array Class	198	(4)
What If I Don't Know How Many Elements I Need Ahead of Time?	202	(2)
Arrays Start at Zero in Visual Basic .NET	204	(1)
Initializing the Array During Declaration	204	(1)
Arrays Are Reference Types	205	(2)
Arrays in Action: A Roman Numeral Calculator	207	(5)
Writing the Code	208	(1)
Examining the Code	209	(1)
Caching Our Variables	210	(2)
Visual Basic .NET Collections	212	(7)
The ArrayList Collection	213	(3)
Queues	216	(2)
Stacks	218	(1)
Eliza and the Beginning of Artificial Intelligence	219	(34)
Eliza in Action	220	(2)
Coding Eliza	222	(2)
Topology of Our Dialog.vb Code Module	224	(2)
Writing the Dialog.vb Code Module	226	(8)
Examining Our Code	234	(1)
Arrays vs. Collections	235	(1)
The Entry Point for Eliza	236	(4)
Is the Patient Discussing the Good Doctor?	240	(1)
Can Eliza Return a Quick Response?	241	(2)
Can Eliza Translate the Patient's Response to Make It a Question?	243	(4)
Return a Previous Patient Phrase	247	(3)
When All Else Fails	250	(1)
Calling the Module from the Form	251	(2)
Conclusion	253	(2)
Handling Errors and Debugging Programs	255	(48)
What Can Possibly Go Wrong?	255	(3)
Types of Visual Basic .NET Errors	258	(1)
The Classic Visual Basic Err Object Is Gone in Visual Basic .NET	259	(1)
Try, Catch, and Finally	259	(8)
Adding Structured Error Handling	261	(1)
The Try...Catch Block	262	(2)
Making Our Simple Program Even More Bullet Proof	264	(2)
The Finally Block	266	(1)
Setting a Breakpoint in Your Code	267	(1)
Running the Program Using the Debugger	268	(8)
Stepping Through Our Code	270	(1)
Helpful Debugging Windows	271	(5)
The Call Stack	276	(2)
The Debug and Trace Classes	278	(15)
Debug.WriteLine	278	(1)
Debug.Assert	279	(2)
Tracing	281	(1)
Adding a Tracing Class to Our Code	282	(2)
Examining the ErrorTrace.vb Code	284	(4)
Setting the Trace Level	288	(1)
Adding the Errors.vb Class to a Program	289	(4)
Adding Event Logging to Your Programs	293	(8)
The Philosophy of Logging Events to the Event Viewer	295	(1)
Adding Event Logging to the Error Trace.vb Class	296	(4)
Using Our New Event Logging Capability	300	(1)
Conclusion	301	(2)
Assemblies in Detail	303	(40)
The Right to Assemble	303	(6)
Private Assemblies	304	(1)
Shared Assemblies	305	(3)
The Other Parts of an Assembly	308	(1)
Reflection: How to Go About Examining Assemblies	309	(1)
The Assembly Spy Program	310	(19)
Building the Assembly Spy Program	313	(2)
Let's Write Some Code	315	(5)
Examining the Code	320	(9)
Self-Examination: Contemplating Our Own Assembly	329	(9)
Code Signing	330	(1)
Creating a Strongly Named Assembly	330	(3)
The Global Assembly Cache Revisited	333	(2)
Assembly Versioning	335	(3)
New Variable Scoping in Visual Basic .NET	338	(3)
Namespace Scope	340	(1)
Determining the Scope of a Variable	340	(1)
Conclusion	341	(2)
File System Monitoring	343	(50)
The File Sentinel Program	344	(28)
How the File Sentinel Program Works	345	(1)
Starting to Write the File Sentinel Program	346	(3)
Adding the Sentinel Class to Our Program	349	(7)
Delegates	356	(2)
Handling the Changed, Created, and Deleted Events	358	(2)
Handling the Renamed and Error Events	360	(1)
Writing to Our Log File	361	(1)
Wiring Up the User Interface	362	(8)
Possible Enhancements to the File Sentinel	370	(2)
Introduction to Windows Services	372	(20)
The Life and Death of a Service	372	(1)
Building Our File Sentinel into a Windows Service	373	(1)
Adding Our Sentinel Class to Our Service	374	(1)
Updating the Service1 .vb File	375	(2)
How Our Service Works	377	(10)
Looking at vbMonitorService in the Services Window	387	(2)
Debugging a Windows Service	389	(3)
Conclusion	392	(1)
Data Access with ADO.NET	393	(38)
From ADO to ADO.NET	393	(6)
ADO.NET from 50,000 Feet	394	(1)
Individual Tables, Not the Join, Are in a DataSet	395	(2)
Comparing Classic ADO and ADO.NET	397	(2)
A Closer Look at the Foundation of ADO.NET: The DataSet Object	399	(1)
The Data Table Object	400	(4)
The DataSet Object and XML	401	(1)
DataView Objects	402	(1)
Managed Providers in ADO.NET	402	(2)
A Common Provider Model	404	(2)
Enough Talk, Let's Look at Some Code	405	(1)
Connecting to Our Data Source	406	(4)
Commands to Manipulate Data from the Data Source	406	(1)
Creating the DataReader Object	407	(1)
Putting the Pieces of Our DataReader Together	408	(2)
Writing a Simple SQLClient Class DataSet Program	410	(1)
Getting Started	410	(19)
Adding a DataAdapter Object to Our Program	414	(4)
Finishing the User Interface	418	(1)
A Sneak Preview of Our Data from the DataAdapter	419	(2)
XML Schema for the Customers Table	421	(1)
Just Add Code	422	(1)
Running Our Program	423	(1)
Editing Our Data	424	(1)
How the Code Works	424	(2)
Updating the Data Source	426	(3)
Conclusion	429	(2)
Data Sets in Detail	431	(46)
Looking Again at the ADO.NET Object Model	431	(3)
Data Sets and XML	434	(2)
Building the Data Set and XML Viewer Project	436	(7)
Adding the Connection, Data Adapter, and DataSet Objects	438	(1)
Adding Code to Our Program	439	(1)
How It Works	440	(1)
Generating XML from Our Data Set	441	(1)
Updating the Data Source	441	(2)
ADO.NET and XML	443	(3)
Examining Our Program's XML Output	443	(1)
The XML Schema Output	444	(2)
Persisting Our XML Information	446	(6)
Testing Our Persistence Code	447	(2)
Examining the DiffGram	449	(3)
Leveraging Our XML File for New Classes	452	(3)
The Xsd.exe Program	452	(3)
Adding a Relationship to Our Program	455	(7)
The Data Sets and XML Program	456	(1)
Creating the Parent/Child Relationship	457	(1)
Adding a Relationship to Our Tables	458	(3)
Examining DataSet Properties	461	(1)
Populating a Data Grid from a Persisted XML File	462	(3)
Run the Program	463	(1)
How the Program Works	464	(1)
Hand Coding a Simple Program	465	(2)
Data Binding	467	(9)
Creating the Program	467	(2)
Adding the Code That Wires the Controls to the Data Set	469	(1)
Run the Program	470	(1)
How It Works	471	(5)
Updating Our Data Grid	476	(1)
Conclusion	476	(1)
ADO.NET Data Binding	477	(20)
The BindingContext Object	477	(2)
The CurrencyManager Object	479	(1)
Record Navigation	479	(1)
A Simple Example	479	(9)
Add the Code	481	(3)
How the Code Works	484	(4)
The DataTable, DataRow, and DataColumn Objects	488	(7)
Examining the DataTable Schema	488	(2)
Building a Table Programmatically	490	(1)
How the Code Works	491	(2)
Finding Specific Records	493	(2)
Conclusion	495	(2)
ASP.NET and Web Services	497	(52)
A Look Back at ASP	497	(1)
Why ASP.NET?	498	(2)
Our First Web Form	500	(14)
New Server Controls	503	(2)
The HTML Presentation Template	505	(3)
Viewing the Code-Behind File	508	(1)
Setting the Properties on Our Web Page	509	(1)
Adding the Calendar Control Code	510	(1)
Running the Web Form	511	(1)
Examining the HTML Sent to the Browser	512	(2)
Building a Loan Payment Calculator	514	(19)
Building Our Loan Application Project	517	(2)
Adding Code to the Code-Behind Form	519	(1)
The Life of a Web Form	520	(1)
How Our Program Works	521	(2)
Taking a Closer Look at Our Drop-Down List	523	(1)
Adding the Payment Schedule Page	524	(2)
Adding Our Class Code	526	(3)
How the Calculator Works	529	(3)
Tracing Our Program	532	(1)
Web Services: The New Marketplace	533	(5)
What Are Web Services?	533	(1)
OK, Now How Do We Communicate?	534	(1)
Finding Out Who Is Offering What in the Global Marketplace	535	(2)
Where Are Web Services Going?	537	(1)
Building a Web Service	538	(10)
Run the Program	540	(3)
Consuming the MagicEightBall Web Service	543	(2)
Building Our Web Services Client Program	545	(1)
Adding a Proxy Class to Our Program	546	(1)
Adding Code to get Our Magic Eight Ball Answers	547	(1)
Conclusion	548	(1)
Visual Inheritance and Custom Controls	549	(46)
Visual Inheritance	549	(6)
Building a Base Form	550	(2)
Adding the Inherited Form	552	(3)
Creating a Custom Control	555	(6)
Changing the Background Color of a Text Box	555	(1)
Building Our Control	556	(1)
Adding Code to Our Control	556	(2)
Adding Our Custom Control to the Host Form	558	(1)
How it Works	559	(2)
Putting it Together: What We've Learned So Far	561	(33)
How Do We Save the Notes? XML, Of Course	562	(2)
Building the Sticky Notes Program	564	(6)
Constructing a Sticky Note	570	(1)
Adding Code to the Sticky Note	571	(3)
How Does it Work?	574	(1)
Adding Even Handler Delegates	575	(2)
The serialize Class in More Detail	577	(5)
When the User Quits the Sticky Notes Program	582	(3)
How the BaseNote Sticky Yellow Form Works	585	(3)
Deploying Our Sticky Notes Program	588	(4)
Installing Our Program on a Client Machine	592	(1)
Install the Sticky Notes Program	593	(1)
Conclusion	594	(1)
Appendix: Some Helpful ADO.NET Wizards	595	(18)
Using the Data Form Wizard	595	(8)
Run the Program	600	(1)
Under the Hood	601	(2)
Generating a Crystal Report from a Data Source	603	(10)
Building a Crystal Report	603	(6)
Getting Ready to View Our Report	609	(4)
Index	613