Visual Basic Object and Component Handbook

PETER VOGEL has been a professional developer for over 15 years. In addition, he is a Visual Basic and Microsoft development instructor for Learning Tree International who wrote Learning Tree's course on Web application development, now taught worldwide. He is editor of the Smart Access newsletter, the leading source for technical information on Microsoft Access. Vogel is based in Goderich, Ontario, Canada.

I. DESIGNING.

1. Designing Components.


Defining Objects. Designing Objects. Objects for the Database Developer. Objects and the Visual Basic Programmer. An Object Model Case Study. Object Overview. Object Relationships. Object Detail. Handling Interfaces. Designing the Object Interface. Properties and Methods. Interface Guidelines. Events. Naming Names. Public and Private Interfaces. Root Objects. Summary.

2. Visual Modeler.


Modeling Tools and Health Clubs. Visual Modeler Benefits and Limitations. What Visual Modeler Does. What Visual Modeler Doesn't Do. A Word From the Wise. UML Benefits and Limitations. Methodology. Implementation. UML and Visual Basic. Working With Visual Modeler. Reverse Engineering With Visual Modeler. The Visual Modeler Display. Manipulating Items and Diagrams. Component View. Adding Components and Component Diagrams. Dependencies. Component Specifications. Class Diagram. Class Specifications. Class Associations. Code Generation. Code Generation Options. Non Code-Generation Related Features. Text Boxes and Notes. The Deployment Diagram. Packages. Reports. Integration. Summary.

II. BUILDING.

3. Coding Objects.


Parameters. Optional Parameters. ParamArrays. Named Parameters. Default Values. ByVal and ByRef. User Defined Types. UDT Workarounds. UDT Support. Enums. Naming Names. Powers of 2. The Basics of Objects. Adding Objects. Working With Objects. New and CreateObject. GetObject. Instantiation. Object References. ActiveX Controls. Variables. Object Variables. CallByName. Case Study: Experimenting With Objects. Coding the Object. Coding the Program. Running the Experiment. Working with Objects. Experimental Lessons. ByVal and ByRef Object Parameters. Summary.

4. Objects.


Working With Class Modules. Classes. Defining Methods. Defining Properties. Public Variables. Property Procedures. Property Let. Property Get. Property Set. Combining Let and Set. Property Exit. Multiple Parameter Properties. Property Data Type. Debugging Error Handling. Persisting Objects. Persistence Events. Saving an Object. Saving the PropertyBag. Restoring the Object. Other Uses. Me. Managing State. Events. Declaring Events. Firing Events. WithEvents. Events with Parameters. Some Restrictions. The ObjPtr Function. Case Study: Asynchronous Methods. Using the Timer Object. The Asynchronous Method. Notifying the Client. Shutting the Object Down. Using a Property. Using an Event. Summary.

5. Components.


Using Components. The References List. CreateObject in Detail. GetObject. Component Definitions. Components and Applications. Objects and Components. Defining a Component. COM Interfaces. Initial Project Options. Assigning Names. Adding Objects. Testing. Debugging Options. Simple and Complex Components. Instancing for Simple Objects. SingleUse versus MultiUse Efficiency Issues. Sharing. Complex Components. Multiple SingleUse Components. MultiUse and SingleUse Components. Controlling Component Creation. Using Objects in the Same Component. Global Objects. Using a Global Object. Global Instancing. Component Design Strategies. ActiveX EXE. Share All. One Copy Each. Multiple Copies/No Sharing. ActiveX DLL. Objects That Create Objects. Initializing. Case Study: The WholesaleManagement Components. Summary.

6. Interfaces.


Object Interfaces. COM Interfaces. Visual Basic and Interfaces. Interfaces and Object Variables. Using Multiple Object Variables. Summing Up. Using COM Interfaces. Adding Interfaces. Accessing Interface Routines. Reducing Code. Implements and Events. Class Module Types. Why Interfaces? Managing Development. Extensibility. Early binding. Other Interface Benefits. Versioning. Case Study: Managing Versions. Hiding Interfaces. Hiding Methods and Properties with Friend. Hiding Objects. User Interfaces. Standalone Components. Suppressing the UI. Logging. Procedure Attributes. Dispatch Ids. Basic Attributes. Advanced Attributes. Creating a Collection Interface. Defining A Simple Collection. Loading the Collection. Returning a Collection. Managing the Collection. A Complete Collection. Enumerating a Collection. A Large Collection: Simple Version. A Large Collection: Complete Version. Case Study: Callbacks. Summary.

7. Deploying.


Performance Matters. Performance Costs. Improving Performance. Talking to Objects. In Process and Out-of-Process. Address Spaces. EXEs. DLLs. DCom and Remote Objects. Load Points. ByVal and ByRef, Methods and Functions. A Final Warning. Threading. Thread Basics. Thread Benefits and Costs. Threading Dangers. Threads and ActiveX DLLs. Threads and ActiveX EXEs. Thread Decisions. Internal Creates. Identifiers. Generating GUIDs. Changing GUIDs. No Compatibility. Binary Compatibility. Project Compatibility. Version Numbers. Installing Components. Tools. Remote Server Files and CliReg. DCOM and DCOMCNFG. Dependencies. Uninstall. Package and Deployment Wizard. Creating Packages. Script Files. Deploy. Visual Component Manager. Working with VCM. Retrieving a Component. Publishing a Component. Changing a Component. VCM Issues. Summary.

III. INTEGRATING.

8. ActiveX Controls.


Introducing ActiveX Controls. A Typical ActiveX Control. ActiveX Control Projects. Debugging an ActiveX Control. ActiveX Controls and Visual Basic. UserControl Lifecycle Events. The Life Cycle of an ActiveX Control. InitProperties. WriteProperties. ReadProperties. UserControl Properties. AccessKeys. The AccessKeyPress Event. Constituent Controls. Alignable. BackStyle. Windowless Controls. ClipBehavior. MaskPicture and MaskColor. The HitTest Event. A HitTest Example. HitBehavior. CanGetFocus. ControlContainer. ContainedControls. ContainerHwnd. DefaultCancel. EditAtDesignTime. EventsFrozen. ForwardFocus. Hyperlink. InvisibleAtRunTime. Parent. ParentControls. Public. ToolboxBitmap. Windowless. The Extender Object. Using the Extender Object. Extender Limitations. Duplicating Names. The Ambient Object. AmbientChanged Event. UserControl Events. EnterFocus, ExitFocus. Hide. Show. Supporting InvisibleAtRunTime. UserControl Methods. AsyncRead. A Sample AsyncRead. PropertyChanged. Procedure Attributes. Procedure ID. AboutBox. Enabled. Text and Caption. Don't Show in Property Browser. Property Category. User Interface Default. Property Pages. Associating a Property Page With a Control. The Life of a PropertyPage. Object Type Properties. PropertyPage Properties. The StandardSize Property. The Changed Property. SelectedControls and SelectionChanged. PropertyPage Events. ApplyChanges. EditProperty. Distributing. Internet Downloads. Authenticode. Safety. IObjectSafety. Licensing. Summary.

9. Data Binding, Providers, Consumers, and RDS.


Data Bound Controls. DataField Binding. Other Options. ActiveX Data Providers. Data Providers. The GetDataMember Event. DataMember. Provider Methods. OLE DB Providers. Creating the Provider. Updates. Commands. Events. Data Consumers. Simple Data Consumer. BindingCollection. PropertyChanged. Service Provider Objects. Defining a Service Provider. Building A Chain. A Sample Chain. Remote Data Services. An RDS Case Study. RDS Architecture. The Default DataFactory. Custom DataFactories. Summary.

10. Design Time Controls.


Introducing DTC. Designing a Simple DTC. RDS. The DTCRDS Specification. An ActiveX Control. Defining Properties. Persisting Properties. The Design Time Control Interface. The GetRunTimeText Method. DTC Output. Registering the DTC. Using the Simple DTC. Integrating Design-Time Controls. Choices. Publishing a Choice. Subscribing to a Choice. Rebinding. Selecting a Choice Object. Tags. User Interface. Callbacks and PopUps. Dynamic Choices. Destroying the Object. Persisting the Object. Debugging. Choice Inspector. Publishing an Object Model. Scenarios. Building a Model. Other Options. Summary.

11. ActiveX Documents.


What Is an ActiveX Document? The Life Cycle of an ActiveX Document. Developing. Containers Matter. Internet Explorer. Microsoft Office Binder. Visual Basic IDE. Container Differences. The Viewport. ActiveX Documents Applications. Getting Started. EXE or DLL. UserDocument Events. Startup and Termination Events. Scroll Event. UserDocument Methods. Positioning the Viewport. UserDocument Properties. HSmallScrollChange, VSmallScrollChange. Scrollbars. MinHeight, MinWidth. ViewportHeight, ViewportWidth, ViewportLeft, ViewportTop. Debugging ActiveX Documents. Menu Negotiation. Implementing and Distributing. Issues in ActiveX Document Development. Managing State. Determining the Container. Exploiting VBD Files. Cooperating UserDocuments. ActiveX Documents and Visual Basic Applications. Summary.

12. Microsoft Transaction Server Objects.


MTS Architecture. Creating a Package. Configuring the Package. The ObjectContext Object. MTS Services. Transaction Management. MTS Transaction Management. Starting a Transaction. Integrating Transaction Management. Coordinating Updates. Security. Programmatic Security. Scalability. Loading and Unloading. State Management. The Shared Property Manager. Activation and Deactivation. Pooling Objects. Returning References. Distributing. Debugging. Summary.

13. Internet Components.


I*Net Applications. Client/Server Development on the Web. HTML and DHTML Elements. The Microsoft Tools. Web Development With Visual Basic. ActiveX Designers. Using an ActiveX Designer. DHTML Applications. Creating a DHTML Project. The DHTML Designer. The DHTMLPage Object. State Management. Debugging and Deploying. IIS Applications. The Life Cycle of an IIS Application. Creating an IIS Application. The IIS Application Designer. Using Templates. Using the ASP Objects. IIS Events. WebClass Processing Cycle. Custom Events. Using the NextItem Property. Maintaining State. Controlling Form Flow. Why You Don't Need IIS Applications. Debugging IIS Applications. Deploying IIS Applications. Summary.

14. Script Components.


Introducing Scripting. ActiveX Scripting. VBScript. Scripting Hosts. Windows Script Host. Using Objects from the Windows Script Host. DHTML Scriptlets. Creating a DHTML Scriptlet Object. Methods, Properties, and Events. Remote Scripting and ASP Remote Objects. On the Server. On the Client. The Call Object. Defining Script Components. XML. Creating a Script Component. Package and Component Tags. Reference, Resource, and Object Tags. Comment Tags. The Registration Tag. Event Tag. Property Tag. Method Tag. The Component, XML, and CDATA Directives. Implements. Registering Script Components. Type Libraries. Using a Scripting Component. Visual Basic. The Window Script Host and ASP. The DHTML Behavior Interface. Assigning Behaviors. Defining the DHTML Behavior. Attaching Events. Event Tag. Property and Method Tags. Behavior Methods and Properties. Element Property. createEventObject. Tools. Summary.

15. COM Add-Ins.


Truth in Marketing. COM Add-ins and the Windows Registry. Visual Basic 5. The Life Cycle of an Add-in. Connecting and Disconnecting. Creating COM Add-ins. Getting Started. OnConnection Routine. OnDisconnection Parameters. Sharing Code. The Connection Designer. The Default Code. Application, Application Version. LoadBehavior. Display Name, Description, Addin is Command-line safe. The Advanced Tab. Integrating Your Add-in and the Host. Displaying a Form. Displaying an ActiveX Document. Responding to Events. Adding Your Add-in to a Menu. Adding a Menu. Adding a Menu Item. Removing a Menu Item. Responding to Events. Debugging and Deploying. Summary.

IV. WINDOWS 2000.

16. Component Services.


Component Services Concepts. Contexts and Configurations. COM+ Features. No Longer Required. Not Yet Available. Load Balancing. Queued Components. Calling a Queued Component. Receiving a Message. Loosely Coupled Events. Constructors. More Security Objects. Debugging COM+. Deploying COM+ Applications. Visual Studio Installer. Summary.

V. APPENDICES.

APPENDIX A: The Wholesale Management Database.


The Database. Relational Tables. Splitting Tables. Relationships. Summary.

Appendix B: Benchmark Code.


The Benchmark Add-In. Sample Code. Main Routine. Multiple Parameters. Optional Parameters. Default Parameters. ByVal Parameters. User Defined Types as Parameters. User Defined Types as Return Values. Using Enums, Constants, and Variables. Assigning Variables, Constants, and Enums. Using Objects as Parameters. Returning Different DataTypes From Functions. Comparing Property Implementations. Setting Object Properties Using Set and Let. Returning Multiple Parameters from an Event. Using ByVal Parameters on an Event. Comparion of SingleUse and MultiUse Load. Calling Methods on Global and MultiUse Objects. Implemented vs Native Methods. Methods Implemented as Functions and Subroutines. Parameters with Out-Of-Process and In-Process Components. Returning Values from Out-of-Process and In-Process Components. About the Author.

Index.