Developing ASP Components P1

Chia sẻ: Thach Sau | Ngày: | Loại File: PDF | Số trang:40

Thêm vào BST

Báo xấu

108
lượt xem 7
download

Download Vui lòng tải xuống để xem tài liệu đầy đủ

When Microsoft first released Active Server Pages (ASP) with the company’s web server, Internet Information Services (IIS), the functionality included with this early release amounted to little more than an ability to handle server-side scripting.

Chủ đề:

Bình luận(0) Đăng nhập để gửi bình luận!

Lưu

Nội dung Text: Developing ASP Components P1

for all ROR Fly Downsky epubcn
,TITLE.22004 Page 1 Thursday, February 22, 2001 1:39 PM Developing ASP Components
,TITLE.22004 Page 2 Thursday, February 22, 2001 1:39 PM
,TITLE.22004 Page 3 Thursday, February 22, 2001 1:39 PM Developing ASP Components Second Edition Shelley Powers Beijing • Cambridge • Farnham • Köln • Paris • Sebastopol • Taipei • Tokyo
,COPYRIGHT.21880 Page 1 Thursday, February 22, 2001 1:39 PM Developing ASP Components, Second Edition by Shelley Powers Copyright © 2001, 1999 O’Reilly & Associates, Inc. All rights reserved. Printed in the United States of America. Published by O’Reilly & Associates, Inc., 101 Morris Street, Sebastopol, CA 95472. Editor: Ron Petrusha Production Editor: Leanne Clarke Soylemez Cover Designer: Hanna Dyer Printing History: April 1999: First Edition. March 2001: Second Edition. Nutshell Handbook, the Nutshell Handbook logo, and the O’Reilly logo are registered trademarks of O’Reilly & Associates, Inc. ActiveX, JScript, Microsoft, MSDN, Visual Basic, Visual C++, Win32, Windows, and Windows NT are registered trademarks and Active Directory is a trademark of Microsoft Corporation. Many of the designations used by manufacturers and sellers to distinguish their products are claimed as trademarks. Where those designations appear in this book, and O’Reilly & Associates, Inc. was aware of a trademark claim, the designations have been printed in caps or initial caps. The association between the image of an asp and developing ASP components is a trademark of O’Reilly & Associates, Inc. While every precaution has been taken in the preparation of this book, the publisher assumes no responsibility for errors or omissions, or for damages resulting from the use of the information contained herein. ISBN: 1-56592-750-8 [M]
,AUTHOR.COLO.21750 Page 1 Thursday, February 22, 2001 1:39 PM About the Author Shelley Powers is a consultant/author with her own company, Burning Bird Enter- prises. In the last several years, she has worked with a variety of distributed, Internet, and Web development applications, for different platforms and using a variety of tools. Shelley has authored or coauthored books on Dynamic HTML, JavaScript, Java, CGI, Perl, P2P, general Web technologies, and more. Shelley can be reached at shelleyp@yasd.com, and her book support site can be found at http://www.burningbirdenterprises.com. Colophon Our look is the result of reader comments, our own experimentation, and feed- back from distribution channels. Distinctive covers complement our distinctive approach to technical topics, breathing personality and life into potentially dry subjects. The animal on the cover of Developing ASP Components, Second Edition, is an asp, which is a term applied to various venomous snakes, including the depicted asp viper (Vipera aspis) of Europe as well as the Egyptian cobra (Naja haje), thought to have been the means of Cleopatra’s suicide. Needing to eat at least 50-60% of their body weight in food per week, European asp vipers hunt by lying in wait for approaching prey. After grabbing and biting a small rodent or other prey, they release it and wait several minutes for it to stop moving; the generally sluggish viper rarely chases prey. Vipers know their home territory very well, which allows quick escape from their asp-kicking natural enemies, serpent eagles, and hedgehogs. This trick hasn’t helped them escape from their greatest threat, the expansion of human civilization, which frequently wipes out large sections of their territory. The chemical composition of asp viper venom can vary from one population to the next, hampering initial antivenin development until 1896, but few viper bite fatalities occur in Europe today. Leanne Soylemez was the production editor and proofreader for Developing ASP Components, Second Edition. Norma Emory was the copyeditor, Mary Anne Weeks Mayo and Colleen Gorman provided quality control, and John Bickelhaupt wrote the index. Hanna Dyer designed the cover of this book, based on a series design by Edie Freedman. The cover image is a 19th-century engraving from the Dover Pictorial
,AUTHOR.COLO.21750 Page 2 Thursday, February 22, 2001 1:39 PM Archive. Emma Colby produced the cover layout with QuarkXPress 4.1 using Adobe’s ITC Garamond font. David Futato designed the interior layout based on a series design by Nancy Priest. Judy Hoer converted the files from MSWord to FrameMaker 5.5 using tools created by Mike Sierra. The text and heading fonts are ITC Garamond Light and Gara- mond Book; the code font is Constant Willison. The illustrations that appear in the book were produced by Robert Romano using Macromedia FreeHand 8 and Adobe Photoshop 5. This colophon was written by Nancy Wolfe Kotary. Whenever possible, our books use a durable and flexible lay-flat binding. If the page count exceeds this binding’s limit, perfect binding is used.
,aspcTOC.fm.21592 Page v Thursday, February 22, 2001 1:38 PM Table of Contents Preface ..................................................................................................................... xi 1. Writing ASP Components ....................................................................... 1 The Role ASP Components Play ..................................................................... 2 Why Use ASP Components? ............................................................................ 3 COM+ Services and ASP Components ............................................................ 5 Accessing Data with ASP Components ........................................................... 8 Windows 2000 Technologies Accessible from ASP Components ............... 10 A Rose by Any Other Name: Programming Language Choice .................... 11 What About ASP.NET? ................................................................................... 13 2. Setting Up the ASP Development Environment .......................... 14 Configuring the IIS Environment .................................................................. 15 Remote Administration of IIS ........................................................................ 27 Using ADSI to Administer IIS Programmatically .......................................... 29 IIS Admin Object Overview .......................................................................... 46 The IIS Base Admin Objects .......................................................................... 59 3. ASP Components and COM ................................................................ 69 Overview of COM for ASP Component Developers .................................... 70 How COM Is Implemented ........................................................................... 76 Notable COM Interfaces ................................................................................ 80 COM Datatypes .............................................................................................. 87 4. ASP Components, Threads, and Contexts ..................................... 91 What Are Threads? ......................................................................................... 92 Threads and Apartments ................................................................................ 95 v Oracle 8i Internal Services for Waits, Latches, Locks, and Memory, eMatter Edition Copyright © 2001 O’Reilly & Associates, Inc. All rights reserved.
,aspcTOC.fm.21592 Page vi Thursday, February 22, 2001 1:38 PM vi Table of Contents The Threading Models ................................................................................... 96 What Are COM+ Contexts? .......................................................................... 110 5. COM+ Services and ASP Components and Applications ....... 114 Developing Component-Based Systems ..................................................... 114 The COM+ Interfaces ................................................................................... 116 Porting MTS Packages to COM+ Applications ............................................ 124 Activating COM+ Applications .................................................................... 125 COM+ Services ............................................................................................. 127 6. ASP Interaction: Scripting and ASP Components .................... 136 Scripting Language Support Within ASP ..................................................... 136 Instantiating Components ............................................................................ 139 COM+ Datatypes and Script/Component Interaction ................................ 145 Passing Arrays as Parameters ...................................................................... 159 Error Handling Between Component and Script ....................................... 174 7. Creating a Simple Visual Basic ASP Component ..................... 180 Creating an In-Process or Out-Of-Process Component ............................. 181 Component Instancing ................................................................................. 182 Component Execution and Threads ........................................................... 184 Creating an ASP Project ............................................................................... 187 Creating Component Methods ..................................................................... 188 Generating, Registering, Installing, and Testing the Component .............. 190 Adding Support for COM+ Services ............................................................ 191 Converting MTS Components for Use with COM+ .................................... 201 Accessing the ASP Built-in Objects ............................................................. 202 Error Handling .............................................................................................. 220 Debugging .................................................................................................... 222 Performance Issues ...................................................................................... 222 8. Creating ASP/ADO Components ..................................................... 225 Accessing ADO from a VB Component ...................................................... 226 Creating a Simple ADO Component ........................................................... 227 The ADO Model ........................................................................................... 233 File and Directory Access with ADO Streams and the Record Object ...... 256 Persisting Data .............................................................................................. 262 9. Creating an ASP Middle Tier with ADO ....................................... 266 How Separate Should the Layers Be? ......................................................... 267 Creating ADO Data Wrappers ..................................................................... 268 Oracle 8i Internal Services for Waits, Latches, Locks, and Memory, eMatter Edition Copyright © 2001 O’Reilly & Associates, Inc. All rights reserved.
,aspcTOC.fm.21592 Page vii Thursday, February 22, 2001 1:38 PM Table of Contents vii Defining Business Objects ........................................................................... 281 Other Data Integrity Issues .......................................................................... 295 10. Server-Side XML Through VB ASP Components ........................ 298 XML Basics ................................................................................................... 298 Formatting XML ............................................................................................ 302 Working with XML in ASP Applications ..................................................... 307 XML and ADO: Saving Recordsets as XML ................................................. 315 11. Take a Message: Accessing CDO from ASP Components ....... 321 A Brief Overview of CDO ........................................................................... 322 The CDO Object Model ............................................................................... 322 Send This URL to a Friend ........................................................................... 324 Working with the Message Body ................................................................ 328 Retrieving and Reading Messages ............................................................... 338 12. Working with Active Directory from ASP Applications ......... 344 A Brief Overview of Active Directory in Windows 2000 ........................... 345 Setting Up an Isolated Active Directory Environment ............................... 345 A Refresher on ADSI .................................................................................... 347 Binding to Active Directory Objects ........................................................... 349 Using the Active Directory Services Viewer ............................................... 355 Manipulating Containers .............................................................................. 357 Searching Active Directory with ADO ........................................................ 362 ASP Example: Add and Manage Users Through the Web ......................... 366 13. Working with MSMQ Components ................................................. 380 MSMQ/ASP Basics ........................................................................................ 380 Working with Queues .................................................................................. 382 Working with MSMQ Messages ................................................................... 389 Using Transactions ....................................................................................... 394 Journaling ..................................................................................................... 407 A Brief Word on Message Security ............................................................. 412 14. Creating C++ ASP Components ...................................................... 414 ATL or MFC .................................................................................................. 415 Using ATL AppWizard to Generate the Basic ASP Component Project .... 416 Adding an ATL Object ................................................................................. 421 Code Changes Based on Adding a New Object ......................................... 426 Adding Methods to the Interface ................................................................ 427 Adding Support for COM+ Services ............................................................ 432 Oracle 8i Internal Services for Waits, Latches, Locks, and Memory, eMatter Edition Copyright © 2001 O’Reilly & Associates, Inc. All rights reserved.
,aspcTOC.fm.21592 Page viii Thursday, February 22, 2001 1:38 PM viii Table of Contents Converting MTS Components for Use with COM+ .................................... 440 Accessing the ASP Built-in Objects ............................................................. 444 Error Handling .............................................................................................. 463 15. Adding Data Access to C++ Components with ADO ............... 468 ADO Access in Visual C++ .......................................................................... 468 The ADO Object Model ............................................................................... 469 The Connection Object ................................................................................ 470 The Recordset Object ................................................................................... 479 The IADORecordBinding Interface ............................................................. 486 The Command Object .................................................................................. 490 Stream and Record Objects ......................................................................... 497 16. The CDO Interfaces from C++ Components ............................... 506 Accessing CDO Interfaces in C++ ............................................................... 506 Creating and Sending a Message ................................................................ 509 Retrieving and Reading Messages ............................................................... 521 17. Accessing Active Directory from C++ Components ................. 528 Binding to Active Directory Objects ........................................................... 529 ADSI Helper Functions ................................................................................ 536 Filtering Collections ..................................................................................... 538 Creating and Removing Active Directory Objects Using ADSI .................. 540 Searching Active Directory with IDirectorySearch ..................................... 544 18. Accessing MSMQ from C++ ASP Components ........................... 550 Adding Support for MSMQ to the C++ Project ........................................... 550 Working with Queues .................................................................................. 553 Searching for a Specific Queue ................................................................... 560 Working with MSMQ Messages ................................................................... 568 Using Transactions ....................................................................................... 574 19. Persistence with ASP Components Using ATL and MFC ........ 581 Combining MFC and ATL ............................................................................ 581 File Access from ASP Components ............................................................. 584 Creating a Serializable Class ........................................................................ 588 Persistence Through Object Serialization ................................................... 591 20. ASP Components Created with Java ............................................. 596 Creating Java Components .......................................................................... 597 Invoking a COM Object in a Java Component ........................................... 606 Oracle 8i Internal Services for Waits, Latches, Locks, and Memory, eMatter Edition Copyright © 2001 O’Reilly & Associates, Inc. All rights reserved.
,aspcTOC.fm.21592 Page ix Thursday, February 22, 2001 1:38 PM Table of Contents ix Working with COM+ Services ..................................................................... 611 The ASP Built-in Object and Helper Interfaces .......................................... 619 Accessing ADO from Java Components ..................................................... 633 21. Creating ASP Components with Delphi ....................................... 642 Using the COM Wizards to Create ASP Components ................................ 642 Manually Adding Support for COM+/ASP .................................................. 653 Working with the ASP Objects .................................................................... 660 Working with ADO ...................................................................................... 668 Working with Windows 2000 Functionality: CDO ..................................... 672 22. Perl-Based Components Using ActiveState’s PDK .................... 677 Setting Up PDK ............................................................................................ 678 Building a Basic Perl Component ............................................................... 679 Accessing the ASP Built-in Objects ............................................................. 689 Working with Data ....................................................................................... 709 Working with the Win2K Environment ...................................................... 716 23. Creating Scripting Language Components ................................. 719 The Windows Script Components Architecture ......................................... 719 Elements of a WSC File ............................................................................... 722 Script Components and ADO ...................................................................... 733 The WSC Wizard .......................................................................................... 736 Creating Script Components with JScript .................................................... 741 Accessing Windows 2000 Functionality ...................................................... 744 A. ASP Built-in Object Quick Reference ............................................. 751 B. The Weaver Database ......................................................................... 776 Index .................................................................................................................... 791 Oracle 8i Internal Services for Waits, Latches, Locks, and Memory, eMatter Edition Copyright © 2001 O’Reilly & Associates, Inc. All rights reserved.
,aspcTOC.fm.21592 Page x Thursday, February 22, 2001 1:38 PM
,ch00.17820 Page xi Thursday, February 22, 2001 1:27 PM Preface Developing ASP components requires knowledge not just of one tool or of one technology, but of many. You have to become familiar with one or more develop- ment tools, such as Visual Basic or Visual C++ (this book covers both, along with Visual J++, Delphi, and Perl), and of course you also have to become familiar with the tools’ underlying language. However, you can’t stop there. ASP components are nothing more than specific types of COM-based compo- nents; that is, they’re COM components designed to interface with Active Server Pages and, most commonly, with Microsoft’s Internet Information Server (IIS). Consequently, you need to develop a certain level of familiarity with COM, the Component Object Model that underlies much of Microsoft’s technology. Becom- ing familiar with COM development in turn requires that you become familiar with threads, so that you can understand how a COM component interacts with a cli- ent as well as the performance issues involved with clients and components that are based on different threading models. Once you’ve become familiar with working with a tool that supports COM compo- nent development and you’re aware of some of the issues involved with COM development, you still have other new technologies to learn. As you develop ASP components, you need to become familiar with web-based development in gen- eral and with the ASP environment in particular. The way in which your compo- nents interact with the “world” they find themselves in—with the web server, the browser, or the web page reader—occurs through built-in objects that Microsoft has provided for ASP development. Originally, the built-in objects could only be instantiated based on specific event handlers. In IIS 4.0, however, the built-in objects could be accessed from Microsoft Transaction Server (MTS) objects. And now, in IIS 5.0, the ASP built-in objects can be accessed from COM+ objects. In addition, COM+ Services provides a number of xi This is the Title of the Book, eMatter Edition Copyright © 2001 O’Reilly & Associates, Inc. All rights reserved.
,ch00.17820 Page xii Thursday, February 22, 2001 1:27 PM xii Preface features (such as transaction management, just-in-time activation, and object pool- ing) that are increasingly important for middle-tier components. So you are going to need to become familiar with COM+ as well. This seems like a very formidable list of tools and technologies, and it is. But we’re not finished yet. Most applications—including more and more ASP applica- tions—require some form of data access. If you need to provide support for data access, then you need to become familiar with ActiveX Data Objects (ADO), the data access technology from Microsoft that’s built on top of OLE DB. Frequently, the content of an ASP page is assembled from data found in a message store, or conversely the data gathered from the user’s interaction with an ASP page is sent in an email or placed in a message store. For applications such as these, you need to become familiar with Collaborative Data Objects for Windows 2000 (CDO). Under Windows 2000 and IIS, a good deal of system information is stored in Active Directory; to retrieve information from and write information to Active Directory, you should know the Active Directory Service Interface (ADSI). Finally, ASP applications, and particularly ASP e-commerce applications, often require communication across systems and involve events that can occur at different times (as, for example, when a user orders products online and a pick list is needed by a system in the warehouse for printing). To take advantage of such loosely cou- pled events, you should be familiar with Microsoft Message Queue (MSMQ). Finally, once you know the programming language used for the component, the tool used to build the component, the implications of developing a COM-based component, the functionality available through built-in and COM+–supplied objects, and how you can access data and the other services needed by your application, then and only then you can take on the functionality that your com- ponent needs to provide. Then, you add additional functionality such as file input and output, object serialization, access to other Windows functionality, and so on. So, do you feel tired before you even start? Well, I want to tell you that develop- ing ASP components really isn’t all that bad, and in fact, you are about to start hav- ing some fun. Not only that, you are also going to learn to work with technology that faces directly on that road racing to the future: the road to distributed and component-based development. This book introduces you to working with COM development as well as working with threads and those pesky little “not threads, not processes”—apartments. It also provides an overview of the ASP operating environment as well as some things you need to know about COM+ and how to work with it. Finally, to com- plete this environment overview, the book explores the interaction between the component and the script used to instantiate and invoke the methods of that com- ponent. This is the Title of the Book, eMatter Edition Copyright © 2001 O’Reilly & Associates, Inc. All rights reserved.
,ch00.17820 Page xiii Thursday, February 22, 2001 1:27 PM Preface xiii Following this introduction, the book then covers component development using Visual Basic and Visual C++. In the case of Visual Basic, chapters include access- ing the intrinsic ASP objects from a Visual Basic component, accessing data using ADO, incorporating messaging with CDO for Windows 2000, using MSMQ, and using components to generate XML. The Visual C++ chapters discuss some of this same material (accessing ASP intrinsics, data access using ADO, using MSMQ), along with persistence using the Microsoft Foundation Classes (MFC) and the ActiveX Template Library (ATL). But if your organization is like so many others nowadays, your group is probably not using just one tool in its web development efforts. It’s just not that unusual for shops to program in Visual C++ and Java, Visual Basic and Delphi, or Visual Basic and Perl. Rather than focus this book on one or two languages, I picked the tools/languages most likely to be used. Conse- quently, separate chapters examine issues in component development using Java, Delphi, and Perl. Each of these chapters is based on the earlier chapters that cover component development using Visual Basic and explores techniques and issues in component development using that language or tool. Who This Book Is For This book is geared to the developer who has worked with one of the target lan- guages/tools but either has not created COM objects before or has not worked with developing ASP components or ASP applications. I hope that the book pro- vides enough of an introduction to COM and threads to make you feel more com- fortable with these topics if you haven’t worked with them before and to provide a good review if you have. The book does not provide an exhaustive overview of COM+ and developing COM+ components but does provide, again, enough of an overview so you feel comfortable working as a developer in a COM+ environ- ment. The book also provides a comprehensive overview of the ASP component envi- ronment, including using tools and wizards in each language/tool to assist in creat- ing the components, and covering every aspect of accessing the built-in ASP components essential for your development effort. In addition, the book also pro- vides good coverage of data access using ADO, messaging using CDO for Win- dows 2000, and message queuing using MSMQ. How This Book Is Structured Informally, this book is divided into four parts. The first part introduces ASP com- ponent development and covers topics that are of concern to all component devel- opers, regardless of the language they use. This part consists of six chapters. Chapter 1, Writing ASP Components, examines some of the reasons that you'd This is the Title of the Book, eMatter Edition Copyright © 2001 O’Reilly & Associates, Inc. All rights reserved.
,ch00.17820 Page xiv Thursday, February 22, 2001 1:27 PM xiv Preface want to develop an ASP component rather than rely on a simple ASP script. It also mentions some of the technologies (COM+ services, ActiveX Data Objects, and Active Directory, to name just three) that you can draw on in developing your components. Chapter 2, Setting Up the ASP Development Environment, examines how to set up your development environment to insure that you can develop with maximum productivity and that your testing doesn't impact on a production sys- tem. In addition, the chapter covers programmatic administration of IIS using Active Directory and the IIS Admin Objects. Chapter 3, ASP Components and COM, examines Microsoft's Component Object Model (COM), which provides the basis for developing all types of components. Chapter 4, ASP Components, Threads, and Contexts, provides developers with the information that they need to know about threading models when developing ASP components, and particularly when accessing global data from the ASP Application object. It also examines the notion of context (a grouping of objects that share the same requirements), an under- standing of which is essential to working successfully with COM+. Chapter 5, COM+ Services and ASP Components and Applications, examines the new inter- faces supported by COM+, shows how components written to take advantage of COM+'s predecessor, Microsoft Transaction Server (MTS), can be ported to COM+, and examines range of services provided by COM+. Chapter 6, ASP Interaction: Scripting and ASP Components, covers an often-neglected component develop- ment topic: your component may be accessed by any of a number of scripting lan- guages—VBScript, JScript, PerlScript, Python, Rexx, etc.—and communication between script and component is often not as seamless as you'd like. The chapter looks at what you can do when developing your ASP component to insure that it can work with as many scripting languages as possible. The second portion of the book, which consists of seven chapters, focuses on component development using Visual Basic. In addition, its chapters serve as a kind of model for how to develop ASP components if you're using a high-level language like Visual Basic that masks much of the complexity of COM and COM+. Chapter 7, Creating a Simple Visual Basic ASP Component, introduces Visual Basic as a tool for ASP component development and examines how to access the ASP object model from Visual Basic. Chapter 8, Creating ASP/ADO Components, looks at accessing data in heterogeneous sources using ActiveX Data Objects (ADO). Chapter 9, Creating an ASP Middle Tier with ADO, discusses component design for multi-tier applications, focusing particularly on the degree of separation between the middle tier and the client tier. The remaining chapters focus on individual technologies that developers frequently use when creating ASP Components. These include the following: • XML is discussed in Chapter 10, Server-Side XML Through VB ASP Components. • Collaborative Data Objects (CDO) for Windows 2000 is covered in Chapter 11, Take a Message: Accessing CDO from ASP Components. This is the Title of the Book, eMatter Edition Copyright © 2001 O’Reilly & Associates, Inc. All rights reserved.
,ch00.17820 Page xv Thursday, February 22, 2001 1:27 PM Preface xv • Active Directory is discussed in Chapter 12, Working with Active Directory from ASP Applications. • Microsoft Message Queue (MSMQ) is examined in Chapter 13, Working with MSMQ Components. The third portion of the book, consisting of six chapters, treats component devel- opment using Visual C++. In addition, its chapters serve as a kind of model for ASP component development using a high-level language like Visual C++ that exposes much of the complexity of COM and COM+. Chapter 14, Creating C++ ASP Components, introduces Visual C++ as a tool for ASP component develop- ment and examines how to access the ASP intrinsic objects from a Visual C++ component. Chapter 15, Adding Data Access to C++ Components with ADO, exam- ines accessing data in heterogeneous sources using ADO. The next three chapters cover the following individual technologies that are often used in developing com- ponents for IIS 5.0: • Collaborative Data Objects (CDO) for Windows 2000 is covered in Chapter 16, The CDO Interfaces from C++ Components. • Active Directory is discussed in Chapter 17, Accessing Active Directory from C++ Components. • Microsoft Message Queue (MSMQ) is examined in Chapter 18, Accessing MSMQ from C++ ASP Components. Finally, coverage of Visual C++ and ASP component development ends with Chapter 19, Persistence with ASP Components Using ATL and MFC, which dis- cusses ways in which your component can save its data to the filesystem. The final portion of this book features individual chapters on component develop- ment using the following programming languages and environments: • Java is covered in Chapter 20, ASP Components Created with Java. • Delphi is discussed in Chapter 21, Creating ASP Components with Delphi. • Perl is covered in Chapter 22, Perl-Based Components Using ActiveState’s PDK. • Windows Script Components (WSC), a scriptable yet powerful development environment for creating ASP components, is discussed in Chapter 23, Creat- ing Scripting Language Components. Finally, the book includes two appendixes. Appendix A, ASP Built-in Object Quick Reference, provides a handy guide to the objects, properties, methods, and events of the ASP object model. Appendix B, The Weaver Database, examines the tables contained in the sample Weaver database, which is used in the book's examples. It can be downloaded from http://vb.oreilly.com. This is the Title of the Book, eMatter Edition Copyright © 2001 O’Reilly & Associates, Inc. All rights reserved.
,ch00.17820 Page xvi Thursday, February 22, 2001 1:27 PM xvi Preface Obtaining the Sample Code All of the example source code from Developing ASP Components, Second Edition, along with the sample Weaver database discussed in Appendix A, is freely down- loadable from the O’Reilly & Associates web site at http://vb.oreilly.com. Just fol- low the link to the book’s title page, then click on the Examples link. Conventions Used in This Book Throughout this book, we have used the following typographic conventions: Italic Represents intrinsic and application-defined functions, the names of system elements such as directories and files, and Internet resources such as web doc- uments. New terms are also italicized when they are first introduced. Constant width Indicates a language construct such as a language statement, a constant, or an expression. Interface names appear in constant width. Lines of code also appear in constant width, as do function and method prototypes. Constant width italic Indicates replaceable parameter names in prototypes or command syntax and indicates variable and parameter names in body text. Indicates a note or tip. Indicates a warning. Comments and Questions Please address comments and questions concerning this book to the publisher: O’Reilly & Associates, Inc. 101 Morris Street Sebastopol, CA 95472 This is the Title of the Book, eMatter Edition Copyright © 2001 O’Reilly & Associates, Inc. All rights reserved.
,ch00.17820 Page xvii Thursday, February 22, 2001 1:27 PM Preface xvii (800) 998-9938 (in the United States or Canada) (707) 829-0515 (international or local) (707) 829-0104 (fax) We have a web page for this book, where we list errata, examples, or any addi- tional information. You can access this page at: http://www.oreilly.com/catalog/devaspcom2 To comment or ask technical questions about this book, send email to: bookquestions@oreilly.com For more information about our books, conferences, software, Resource Centers, and the O’Reilly Network, see our web site at: http://www.oreilly.com For technical information on Visual Basic programming, to participate in VB dis- cussion forums, or to acquaint yourself with O’Reilly’s line of Visual Basic books, you can access the O’Reilly Visual Basic web site at: http://vb.oreilly.com Acknowledgments I want to thank the book’s tech reviewers, Daniel Creeron and Matt Childs, for their thorough reviews and helpful comments. I also want to thank Bob Herbst- man and Tatiana Diaz, members of the O’Reilly editorial staff, for their hard work and dedication to this project. I also want to thank my long-suffering editor, Ron Petrusha. This is the second edi- tion of this particular book, and he’s done a terrific job of editing both of them. I also want to thank my coworkers at Skyfish.com for being a terrific group of peo- ple. Specifically, I want to thank a certain group of Australians in the company— guys, the best to you all, and may your dreams find you. Finally, thanks to my readers—I’m here because you’re here. This is the Title of the Book, eMatter Edition Copyright © 2001 O’Reilly & Associates, Inc. All rights reserved.