Visual C Net Developer Guide

522 Pages·2002·7.56 MB·English

by  John Mueller

Visual C++ .NET Developer’s Guide
John Paul Mueller
McGraw-Hill/Osborne
2600 Tenth Street
Berkeley, California 94710
U.S.A.
To arrange bulk purchase discounts for sales promotions, premiums, or fund-raisers, please
contact McGraw-Hill/Osborne at the above address. For information on translations or book
distributors outside the U.S.A., please see the International Contact Information page
immediately following the index of this book.
Copyright © 2002 by The McGraw-Hill Companies. All rights reserved. Printed in the United
States of America. Except as permitted under the Copyright Act of 1976, no part of this
publication may be reproduced or distributed in any form or by any means, or stored in a
database or retrieval system, without the prior written permission of the publisher, with the
exception that the program listings may be entered, stored, and executed in a computer
system, but they may not be reproduced for publication.
1234567890 CUS CUS 01987654321
Book p/n 0-07-213262-0 and CD p/n 0-07-213282-5
parts of
ISBN 0-07-213281-7
Publisher
Brandon A. Nordin
Vice President & Associate Publisher
Scott Rogers
Acquisitions Editor
Ann Sellers
Project Editor
Katie Conley
Acquisitions Coordinator
Tim Madrid
Technical Editor
Bill Burris
Copy Editor
Carl Wikander
Proofreader
Carol Burbo
Indexer
Irv Hershman
Computer Designers
Tara A. Davis, Lauren McCarthy
Illustrators
Michael Mueller, Greg Scott, Lyssa Wald
Cover Illustration
Eliot Bergman
Cover Series Design
Greg Scott
This book was composed with Corel VENTURA™ Publisher.
Information has been obtained by McGraw-Hill/Osborne from sources believed to be
reliable. However, because of the possibility of human or mechanical error by our sources,
McGraw-Hill/Osborne, or others, McGraw-Hill/Osborne does not guarantee the accuracy,
adequacy, or completeness of any information and is not responsible for any errors or
omissions or the results obtained from use of such information.
This book is dedicated to Micah Schlobohm.
I appreciate her kindness, thoughtfulness, and desire to help.
She’s the kind of friend that more people should have, but unfortunately don’t.
About the Author
John Mueller is a freelance author and technical editor. He has writing in his blood, having
produced 53 books and over 200 articles to date. The topics range from networking to
artificial intelligence, and from database management to heads down programming. Some of
his current books include a SOAP developer guide, a small business and home office
networking guide, and a Windows 2000 Performance, Tuning, and Optimization book. His
technical editing skills have helped over 25 authors refine the content of their manuscripts.
John has provided technical editing services to both Data Based Advisor and Coast
Compute magazines. He’s also contributed articles to magazines like SQL Server
Professional, Visual C++ Developer, and Visual Basic Developer. He is currently the editor
of the .NET electronic newsletter for Pinnacle Publishing.
When John isn’t working at the computer, you can find him in his workshop. He’s an avid
woodworker and candle maker. On any given afternoon, you can find him working at a lathe
or putting the finishing touches on a bookcase. One of his newest craft projects is making
glycerin soap, which comes in handy for gift baskets. You can reach John on the Internet at
[email protected]. John is also setting up a Web site at: http://www.mwt.net/~jmueller/; feel
free to look and make suggestions on how he can improve it. One of his current projects is
creating book FAQ sheets that should help you find the book information you need much
faster.
Acknowledgments
Thanks to my wife, Rebecca, for working with me to get this book completed. I really don’t
know what I would have done without her help in researching and compiling some of the
information that appears in this book (especially the Glossary). She also did a fine job of
proofreading my rough draft and page proofing the final result.
Bill Burris deserves thanks for his technical edit of this book. He greatly added to the
accuracy and depth of the material you see here. I really appreciate the time he devoted to
checking my code for accuracy. Bill also supplied some of the URLs you see in the book and
other helpful tips and hints.
Matt Wagner, my agent, deserves credit for helping me get the contract in the first place and
taking care of all the details that most authors don’t really consider. I always appreciate his
help. It’s good to know that someone wants to help.
Finally, I would like to thank Ann Sellers, Timothy Madrid, Katie Conley, Carl Wikander, and
the rest of the production staff at McGraw-Hill/Osborne for their assistance in bringing this
book to print. I especially appreciate Ann’s patience when things didn’t go exceptionally well.
Tim provided me with many thought-provoking messages and was always willing to talk with
me when I needed help.
Introduction
Unless you’ve been hiding in a cave in a remote part of the earth, Microsoft has inundated
you with news of .NET by now. Microsoft’s marketing machine is working overtime, as usual,
to ensure you don’t miss their latest and greatest product. If you listen to the Microsoft hype,
it seems that they expect everyone to drop billions (trillions?) of lines of code and adopt
.NET tomorrow. What the hype doesn’t mention is that adopting .NET completely means
starting from scratch.
The real world is a different place than the fantasyland of Microsoft hype. In the real world,
developers have to maintain existing code at the lowest possible cost and still produce new
applications in record time. The task seems impossible when you have two completely
different technologies to develop these applications. On the one hand, you have the realm of
MFC and the Win32 API. On the other hand, you have the new .NET Framework. Which do
you choose for a given task?
Answering the question of which technology to use is one of the biggest problems this book
will tackle. We’ll discuss how to use the old, the new, and, most importantly, the mixed
environments of Visual C++ .NET. Knowing when .NET can actually help you create an
application faster is the key to managing application development in an environment where
you have two different architectures to consider.
Microsoft’s .NET Framework is an exciting new technology for a developer looking for every
productivity enhancement available. My purpose in writing this book is to help you balance
the usefulness of this new technology against the need to maintain existing code. By the
time you complete this book, you’ll not only know how to work with .NET to create some
relatively complex applications, but you’ll better understand when .NET is a good choice for
application development.
What’s in This Book
Visual C++ .NET Developer’s Guide contains a mix of theory and programming examples,
with a heavy emphasis on the programming examples. You’ll find a mix of Win32, MFC,
ATL, and .NET code within the book. In some cases, I’ll show you how to mix an existing
technology with a new one—Visual C++ .NET is definitely a transitional language, one that
will help you move from Win32 application development to .NET. Here’s a brief overview of
the six parts of this book.
Part I—Visual C++ in General
This part of the book introduces you to some of the new features in Visual C++ .NET. We’ll
also discuss some basic programming principles. You’ll learn how to create various types of
applications. Most of the code in this part is unmanaged. However, this part includes some
managed code examples that show how you’d create the same result as an unmanaged
counterpart using the .NET Framework.
You’ll also learn some advanced coding processes in this part of the book. We’ll discuss
threads in Chapter 3, and I’ll show you how to create two types of threads. The graphics
programming examples in Chapter 4 include both static graphics and animated graphics
using GIFs. Chapter 5 will help you understand the intricacies of Active Directory, while
Chapter 6 shows how to create components using both ATL and MFC.
Part II—Visual C++ .NET and Database Management
Database management is an essential part of every business today. Chapter 7 of this part
tells you about the various technologies and indicates when you can best use them to your
advantage. We also look at how to create and use DSNs.
Chapter 8 is the unmanaged coding example for this part. You’ll learn how to use OLE-DB to
create a basic database application that includes a form view, printing, and search routines.
This section of the book also tells you how to get around certain problems with the Visual
C++ .NET environment. For example, Visual C++ .NET doesn’t ship with all of the controls
found in Visual Studio 6. Some of your applications might require these controls, so I show
how to install them. Unfortunately, some controls won’t work even if you do install them, and
I show you how to get around some of these problem areas.
Chapter 9 is the managed coding example for this part. We discuss ODBC .NET in this
chapter. Unfortunately, ODBC .NET wasn’t ready in time for the book, so you won’t see a
coding example. We’ll create a managed example using ADO .NET that includes use of the
new DataGrid control (among others). This section also shows how to create a print routine
and other database application basics.
Part III—Visual C++ and Online Computing
Distributed applications are becoming more prominent as businesses move to the Internet in
an effort to remain connected with partners, employees, and customers. This part of the
book shows you how to work with SOAP and discusses Web Services in general. You’ll also
learn how to work with alternative devices such as PDAs. Chapter 10 contains a simple
ASP.NET example that helps you understand the benefits of this technology. Chapter 11
shows you how to create both ISAPI Filters and ISAPI Extensions as well as a SOAP
application that relies on the Microsoft SOAP Toolkit. Most of the examples in this part of the
book rely on unmanaged programming techniques.
Part IV—Visual C++ .NET and Microsoft.NET
Most of the examples in this part of the book rely on managed programming techniques.
You’ll learn how to create various types of managed applications that rely exclusively on the
.NET Framework. Chapter 12 is unique because it compares Visual C++ .NET to C# and
even provides an example in both languages for comparison purposes. This is also the
chapter to read if you want to learn how to move your applications to .NET. Chapter 13 is
your key for learning about the new attributed programming techniques provided with Visual
C++ .NET. Attributes greatly reduce the coding burden for the developer. Examples in this
chapter use both managed and unmanaged coding techniques. Chapter 14 shows you how
to work with managed components. You’ll also create a custom attribute and use reflection
to read its contents from the compiled application.
Part V—The Developer View of Visual C++ .NET
This part of the book contains a mix of topics that didn’t fit well anywhere else, but are
extremely important for the developer. Chapter 15 discusses the inner workings of Security
within Windows 2000 and Windows XP. Security is an important topic in a world where
crackers make it their business to test your applications for holes in every way possible.
Chapter 16 shows how to create administration tools for your applications. Most complex
applications require some type of configuration and “tweaking” as part of the installation and
maintenance cycle. Using the Microsoft Management Console (MMC) to maintain your
application makes sense because it reduces the user interface design burden for the
developer and reduces the amount of code required to create the management program.
Chapter 17 shows you how to create various types of help files. Microsoft is always moving
on to some new form of help, but sometimes you need to use the older forms of the help file
as well. This chapter shows how to create both. Finally, Chapter 18 shows how to package
your application once you finish building it.
Part VI—Appendixes and Glossary
This last part of the book contains two appendixes and a glossary. Appendix A tells you how
to get the best deal for your next component purchase. It also helps you find some “must
have” components for your next application. Appendix B is an online resource guide that
helps you locate additional information about Visual C++ .NET. Sometimes it’s good to know
where to find additional help. Finally, the Glossary contains a complete list of every esoteric
term and acronym used in the book.
What You’ll Need
There are some assumptions that I’ve made while writing the application programming
examples in this book. You need at least two machines: a workstation and a server. This
two-machine setup is the only way that you’ll see Visual C++ .NET in action and truly know it
works as anticipated. In addition, your development workstation and server must meet the
minimum .NET requirements (and hopefully provide more than the minimum). You might
experience problems with the database and other large examples when running a minimal
machine configuration.
During the writing of this book, I used a Windows 2000 and Windows XP workstation.
There’s no guarantee that any of the code in the book will work with Windows 9x; although,
most of it will. The server was loaded with Windows 2000 Server with the latest patches and
service packs installed. You’ll need a Pocket PC compatible PDA to work with the SOAP
example in Chapter 10. You must install the latest service packs for all products before the
examples will work properly. .NET is a new technology and relies on the latest versions of
many DLLs and the .NET Framework.
Note
Many of the concepts you’ll learn in this book won’t appear in your online
documentation. Some of it is so new that it appears only on selected Web
sites. You’ll find either a tip or a note alerting you to the location of such
information throughout the book. In addition, Microsoft made some material
available only through selected channels, like an MSDN subscription. Other
pieces of information are simply undocumented, and you won’t find them
anywhere except within a newsgroup when someone finds the feature
accidentally.
I tested all of the examples in this book with Visual C++ .NET Enterprise Architect Edition.
Microsoft made a considerable number of changes to Visual C++ .NET, so none of the
examples will load in previous versions of the product, even if the code will compile. None of
these examples are guaranteed to work with any other programming language products, and
none of them will work with the educational versions Visual Studio.
Some of the example programs rely on a database manager. I used Microsoft Access for all
of the examples in this book for the sake of simplicity. The source code CD contains copies
of all of the databases used in this book.
Conventions Used in This Book
In this section we’ll cover usage conventions. This book uses the following conventions:
[<Filename>] When you see square brackets around a value, switch, or
command, it means that this is an optional component. You
don’t have to include it as part of the command line or dialog
field unless you want the additional functionality that the
value, switch, or command provides.
<Filename> A variable name between angle brackets is a value that you
need to replace with something else. The variable name
you’ll see usually provides a clue as to what kind of
information you need to supply. In this case, you’ll need to
provide a filename. Never type the angle brackets when you
type the value.
ALL CAPS There are three places you’ll see ALL CAPS: commands,
filenames, and case-sensitive registry entries. Normally,
you’ll type a command at the DOS prompt, within a PIF file
field, or within the Run dialog field. If you see ALL CAPS
somewhere else, it’s safe to assume that the item is a case-
sensitive registry entry or some other value like a filename.
File | Open Menus and the selections on them appear with a vertical
bar. “File | Open” means “Access the File menu and choose
Open.”
italic There are three places you see italic text: new words, multi-
value entries, and undefined values. You’ll always see a
value in italic whenever the actual value of something is
unknown. The book also uses italic where more than one
value might be correct. For example, you might see
FILExxxx0 in text. This means that the value could be
anywhere between FILE0000 and FILE9999.
monospace It’s important to differentiate the text that you’ll use in a
macro or type at the command line from the text that
explains it. This book uses monospace type to make this
differentiation. Every time you see monospace text, you’ll
know that the information you see will appear in a macro,
within a system file like CONFIG.SYS or AUTOEXEC.BAT,
or as something you’ll type at the command line. You’ll even
see the switches used with Windows commands in this text.
There is another time you’ll see monospace text. Every code
listing uses monospaced code to make the text easier to
read. Using monospaced text also makes it easier to add
things like indentation to the coding example.
URLs URLs will normally appear highlighted so that you can see
them with greater ease. The URLs in this book provide
sources of additional information designed to make your
development experience better. URLs often provide sources
of interesting information as well.
Icons
This book contains many icons that help you identify certain types of information. The
following paragraphs describe the purpose of each icon.
Note
Notes tell you about interesting facts that don’t necessarily affect your ability
to use the other information in the book. I use note boxes to give you bits of
information that I’ve picked up while using Visual C++, Windows 9x,
Windows 2000, or Windows XP.
Tip
Everyone likes tips, because they tell you new ways of doing things that you
might not have thought about before. Tip boxes also provide an alternative
way of doing something that you might like better than the conventional (first)
approach I provided.
Caution
This means watch out! Cautions almost always tell you about some kind
of system or data damage that’ll occur if you perform certain actions (or
fail to perform others). Make sure you understand a caution thoroughly
before you follow any instructions that come after it.
Browser
Alert The Internet contains a wealth of information, but finding it can be
difficult, to say the least. Web Links help you find new sources of
information on the Internet that you can use to improve your
programming or learn new techniques. You’ll also find newsgroup
Web Links that tell where you can find other people to talk with
about Visual C++. Finally, Web Links will help you find utility
programs that’ll make programming faster and easier than before.
What Happened to Hungarian Notation?
At one time, Hungarian notation was an essential for developers because the IDEs provided
with early compilers didn’t tell you much about the variables, methods, and other
programming constructs in your application. Today, IDEs commonly provide detailed
information about the constructs in your application and even help you to make good
decisions about formatting your code. Hungarian notation has become a verbose method of
writing code that addresses a problem that doesn’t exist anymore.
For the most part, this book doesn’t use Hungarian notation. The variable names you see
describe the purpose of the variable, rather than the variable type. You might see a bit of
Hungarian notation floating around in places where I felt it would help, but these uses are
minimal.
Part I: Visual C++ In General
Objectives
§ Learn about the new features of Visual C++ .NET
§ Obtain an overview of the development tools
§ Create a workstation and server setup
§ Learn to build various types of desktop applications
§ Discover how threads can help you create more efficient applications
§ Build applications that use standard graphic files
§ Build applications that use animation techniques
§ Learn how to work with Active Directory
§ Create ActiveX controls using two different techniques
Chapter List
Chapter 1: Getting Started
Chapter 2: Building Desktop Applications
Chapter 3: Working with Threads
Chapter 4: Working with Graphics
Chapter 5: Working with Active Directory
Chapter 6: Creating Components