COM+ Programming: A Practical Guide Using Visual C++ and ATL

Description

• Copyright 2001
• Dimensions: 7" x 9-1/4"
• Pages: 560
• Edition: 1st

• Book
• ISBN-10: 0-13-088674-2
• ISBN-13: 978-0-13-088674-3

Several books teach COM and COM+, but this is one of the first to focus on COM/COM+ from a developer's perspective. Using case studies and practical programming examples, the author uncovers COM and COM+ in detail -- and shows how to avoid the traps and pitfalls that await the unwary. COM/COM+ expert Pradeep Tapadiya presents techniques for designing interfaces, building COM servers, synchronization, security, transactions, event notification issues, working with queued components, and administering distributed object environments. This book serves both novice programmers and experienced developers who wish to use COM+ to develop applications in the enterprise.



Extras

Author's Site

Visit the author's web site to obtain Errata and Source Code for this title.



Sample Content

Table of Contents

I. THE FOUNDATION.

1. The Component Model.

Component Reusability. Traditional Software Reusability. Reference Hardware Components. Simulation Program. Role of the Linker and the OS Loader. Dynamic Link Library. Fixing a Defect. Hardware Component Model. Separating Interface from Implementation. Common Aspects of C++ Language. Virtual Methods in C++ and Memory Layout. Interface as an Abstract Base Class. Dynamic Selection of a Component. Extending the Interface Functionality. Managing the Lifetime of an Object. Optimizations. Error Reporting. The Essence of COM. Summary. References.

2. Designing Interfaces.

Why a New Language? Programming Language Independence. Remote Transparency. Interface Definition Language (IDL). IDL Attributes. IDL Design Goals. Remote Transparency. Programming Language Independence. Semantic Information. Standardized Calling Conventions. Memory Management. Identification. Compiled Type Information. Component Identification. Processing IDL Files. IDL File Structure. The Preprocessor Section. The Interface Section. The Type Library Section. IDL Syntax. Defining Interface Methods. Defining IDL Interfaces. Defining COM Classes. Defining IDL Libraries. Automation. Basic Data Types. Strings. Booleans. Variants. Safe Arrays. Automation-Compatible Interfaces. Collections and Enumerations. Interfaces and Marshaling. Memory Management. Organizing Multiple IDL Files. Putting It All Together. Summary. References.

3. Components.

From C++ to COM—A Quick Tour. Implementing Interfaces. Method Implementation. Instantiation Logic. The TV Client. The COM+ Catalog. Revisiting C++ Code. Multiple Classes in a Server. Multiple Instances of a Class. Storing Configuration Information. Memory Cleanup. Implementing COM Objects. Using Multiple Inheritance. Implementing the Root Interface. ATL is Our Friend. Tear-Off Interfaces. Reusing Components. Containment. Aggregation. Error Reporting. Summary. References.

II. THE EXTENSION.

4. Essence of COM+.

Enterprise Systems. Security. Scalability. Sharing Resources. Transactions. Three-Tier Architecture. Windows DNA. COM+ = Simplified Development. Administrative Control. Transaction Services. Security Services. Synchronization Services. Queued Components. Event Service. Object Pooling. Just-In-Time (JIT) Activation. Remote Deployment. Summary. References.

5. COM+ Programming Model.

Attribute-Based Programming. The COM+ Catalog. Configuring a Component. Component Initialization. Developer-Specified Attributes. COM+ Context. Contexts and Interception. Interception and Performance. Object Context. Default Context. Call Context. Object Activation. In-Process Activation. Out-of-Process Activation (Local Host). Remote Activation (Distributed Computing). Executing in a Different Context. Summary. References.

6. Concurrency.

Multithread Programming. A Simple Example. Multithreading Issues. Apartments. Single-Threaded Apartments (STA). Multithreaded Apartments (MTA). Thread-Neutral Apartments (TNA). Configuration Settings. Activities. Apartments and Standard Marshaling. Dispatching Calls to an STA. Dispatching Calls to an MTA. Dispatching Calls to a TNA. Cross-Context Access. Developing Thread-Safe COM Code. Shared Data Conflicts. Waiting for an Event. Sharing State Across Multiple Objects. Summary. References.

7. Security.

The COM+ Security Model. Windows NT Security System Basics. Security Issues Under COM. Security Service Providers (SSPs). Security Blankets. Declarative Security. Default Settings. Application-Specific Settings. Server-Side Security Programming. Client-Side Security Programming. Impersonation Levels. Identity and Authentication Services. Client Acting as a Server. Adjusting Security for a Proxy. Summary. References.

8. Transactions.

The Stock Trader. The Database Layer. The Business Logic. The Simulation. Transaction Theory. COM+ Support for Transactions. Configuring Transactions. Programmatic Voting. The Architecture. Resource Managers. The Distributed Transaction Coordinator. Automatic Transactions through COM+. Manual Transactions. Compensating Resource Manager. Summary. References.

9. Message Queuing.

Message-Based Queuing. The Need for Queuing. Why Use MSMQ? MSMQ Overview. MSMQ Servers. MSMQ Clients. Queue Types. Queue Naming. MSMQ COM Components. Sending and Receiving Messages. Guaranteed Delivery. Responding to a Message. Sending Objects in the Message Body. Transactions. Queued Components. A Simple Phone Book Example. Queued Component Architecture. Getting a Response. Transaction Support. Summary. References.

10. Events.

Introduction. Tightly Coupled Events (TCEs). Connection Points. Receiving Messages with MSMQ Events. Loosely Coupled Events (LCEs). COM+ Events Architecture. A Simple Event Example. Transient Subscriptions. Events and Queued Components. Events and Filtering. Summary. References.

11. Scalability.

Introduction. Resource Dispensers. Just-in-Time (JIT) Activation. Object Pooling. Requirements for Poolable Objects. Asynchronous Method Calls. Asynchronous Clients. Asynchronous Servers. Canceling a Synchronous Call. COM+ Pipes. Summary. References.

12. Administration.

Overview. COM+ Administration Object Model. COMAdminCatalog Object. COMAdminCatalogCollection Object. COMAdminCatalogObject Object. Programming Considerations. Error Handling. Administrative Tasks and Transactions. Some Common Administrative Tasks. Uninstalling an Application. Installing an Application. Deploying an Application. Future Enhancements. Summary. References.

Index.

Preface

Introduction

Ever since software development became an engineering discipline, software development teams everywhere in the world have faced similar development and deployment problems. Among other things, developers today are concerned about:

• Reusing code that has been tested and used in other applications
• Developing flexible applications that can be customized to the users needs, but not at the expense of overburdening the development team
• Addressing anomalies and add features after the application has been shipped, while avoiding a complete rewrite of the application
• Improving application development time by leveraging against software code developed by third party software vendors
• Developing distributed and non-distributed applications in a similar manner

All of these challenges and many more are addressed by a single technology: the Microsoft Component Object Model, better known as COM. COM is a framework for developing software components, small binary executables, that provide services to applications and other components.

The incredible explosion of the Internet has caused a revolution in the way information has to be made available to the users. In developing enterprise systems, the traditional client/server model has been replaced with a three-tier programming model, enhanced for Internet applications. Developing such enterprise systems is a time- and resource-consuming affair, as the system has to meet extra enterprise-level requirements such as scalability, robustness, security, transaction support, etc.

COM+ is an advanced run-time environment that provides services to meet many of the above-mentioned enterprise-level requirements. It is an integral part of the Windows 2000 Operating System. Developers can leverage the services provided by COM+, instead of building the services themselves.

This book focuses on understanding the COM+ architecture from a developer's perspective and building COM+ applications using Microsoft Visual C++ and the Active Template Library (ATL).

COM+ is not a radical departure from COM--it is just the next stage in the evolution of the COM programming model. As a matter of fact, it is very difficult to determine where COM ends and where COM+ begins. In order to understand the COM+ architecture and the services provided by COM+, it is necessary to understand the fundamental component model at the heart of COM+. To this end, the book is divided in two parts. The first part builds the foundation that is COM and the second part explains the services provided by COM+ version 1.0.

About This Book

The purpose of writing this book is twofold. To help you:

1. Understand the COM/COM+ architecture, and
2. Explore the services provided by COM+ 1.0.

In order to achieve the stated goals, I have presented the material from a developer's perspective. I have illustrated the key concepts by writing some simple applications using Microsoft Visual C++ 6.0, Platform SDK (January 2000), and ATL 3.0. This book provides enough C++ code and tools to enable the readers to be more productive and to carry out further research.

As we progress through unfolding the COM+ architecture and services, I first present one or more software-engineering problems at hand, and then discuss the solution that COM+ has to offer. Whenever applicable, code snippets are provided to illustrate and explain the concepts.

In an attempt to focus on COM+ 1.0 architecture and services, I have refrained from including material that is not of any practical importance. Consequently, I do not discuss the origin and history of COM, or even Microsoft Transaction Server (MTS), a precursor to COM+ 1.0. However, whenever possible, I have touched upon the new services that are being planned for the future release of COM+ (COM+ 1.x).

Choice of Language

COM+ is a specification. As such, it is language independent. However, most COM-based components are currently written in C++. This book uses C++ for almost all the server-side code. Client-side usage is shown in C++, VB, or in any other language that is appropriate for the given situation.

Prerequisites

The most important prerequisite for this book is your willingness to learn.

The book is written for intermediate to advanced developers. It is assumed that the readers have a working knowledge of the following:

• Windows 2000 Operating System
• C++ programming language
• VB programming language
• C++ templates. In particular, familiarity with C++ Standard Template Library (STL) is helpful
• Developing programs using Win32 API
• Windows 2000 security model

Strictly speaking, many of these assumptions can be relaxed. For example, knowledge of Win32 API or C++ templates is helpful but not mandatory. As we go through developing sample code, I am confident readers will automatically pick up the missing information.

Sample Code

All the examples provided in the book are concise and complete. For brevity, I sometimes show only the relevant code snippet in the book. However, complete source code is available on the companion CD. All the examples and tools have been compiled under Visual C++ 6.0 SP3 and Platform SDK (January 2000), and have been tested with the release version of Windows 2000 OS.

References

This book frequently refers to other books, Microsoft's Knowledge Base articles, articles from various journals and from Microsoft's Developers Network (MSDN) Library. All the references for a particular chapter are listed at the end of the chapter. Each reference is indexed by a keyword that uses a combination of author's last name and year the reference was published. For example, Don Box's book Essential COM, which was published in 1998, is indexed as Box-98. In the book, each time I have to refer to an article, I use the keyword index of the reference.

Chapter Organization

The book is divided into two parts. The first part, The Foundation, consists of three chapters. It explains the fundamentals of Component Object Model and shows how to design and develop COM-based applications. Each chapter builds on the knowledge from the previous chapter.

The second part, The Extension, focuses on COM+ architecture and services provided by COM+ 1.0. Each chapter focuses on a specific aspect of COM+. These chapters are largely independent of each other. Chapter five, however, explains the COM+ programming model, and should be read before looking into any other COM+ chapter.

Companion CDThe companion CD contains the following:

1. The source code for the C++ utility classes and tools developed in the book.
2. The entire source code for all the examples arranged by chapters.

More information about the contents of the CD can be found in the read-me file on the CD.



Updates

Submit Errata

