Sebastopol, CA 95472
(800) 998-9938 (in the United States or Canada)
(707) 829-0515 (international/local)
(707) 829-0104 (fax)
The web site for the book lists examples, errata, and plans for future editions. You can access this page at:

To ask technical questions or comment on this book, send email to:

Or to me directly:

For more information about our books, conferences, software, resource centers, and the O'Reilly Network, see our web site:

Acknowledgments
A book is by no means the product of just the author's work. It is the result of many events and individuals, like links in a
chain. I cannot possibly name everyone, ranging from my parents to my friends. I am especially grateful for my two friends
and colleagues, Marcus Pelletier and Chris W. Rea. Marcus worked with me on large COM+ projects, and together we
confronted the unknown. Marcus's thoroughness and technical expertise is a model for every programmer. Chris's comments
and insight into a reader's mind have contributed greatly to this book's accuracy, integrity, and flow. I wish to thank Yasser
Shohoud for verifying my approach to transaction processing and sharing with me his own, Richard Grimes for reviewing the
book, and Roger Sessions for writing the Foreword. Thanks also to Johnny Blumenstock for providing me with a place to write.
Finally, this book would not be possible without my wife, Dana, whose constant support and encouragement made this book a
reality. Thank you, Dana.
Chapter 1. COM+ Component Services
By now, most developers of large-scale enterprise applications are convinced of the benefits of component-oriented
development. They have discovered that by breaking a large system down into smaller units, they can write code that is
easier to reuse on other projects, easier to distribute across multiple computers, and easier to maintain. As long as these
components adhere to a binary standard that defines how they communicate with one another, they can be invoked as
needed at runtime and discarded when they have finished their work. This type of application is also particularly suited to the
Web, where clients request services of remote applications and then, once satisfied, move on to other tasks.
For nearly a decade, the Microsoft Component Object Model (COM) has been the standard for components that run on
Windows machines, including Windows 9x and Me clients and Windows NT and 2000 servers. The COM model is well

documented by the Microsoft Component Object Model Specification. Tools such as Visual C++ and Visual Basic make it easy
to create COM components, and scores of books, training classes, and articles are available to teach programmers how to use
them. Many features of the Windows operating system are now implemented as COM components, and many companies have
invested heavily in COM-based systems of their own.
In July 2000, Microsoft announced a radically new component model as part of its .NET development platform, suddenly
calling into question the viability of existing COM applications. .NET components bear little resemblance to legacy COM
components and are not backwards compatible. They can be made to interoperate with COM components but do not do so
naturally.
When it comes to the services and tools programmers use to build enterprise-scale .NET applications, however, one facility
continues to provide the necessary runtime infrastructure and services: COM+ component services. These services have been
available on Windows 2000 since its release, but they will gain greater importance in the months ahead. As it turns out, they
Page 6 of 238
10/3/2002file://F:\Documents%20and%20Settings\Administrator\Local%20Settings\Temp\Rar$EX0...
offer a bridge between traditional COM and .NET applications, making your understanding and mastery of them as important
now as it has ever been.
In this chapter, we provide a quick overview of the COM+ suite of component services and then introduce you to the
Component Services Explorer, your primary tool for building and managing both COM and .NET enterprise applications. You
will also create, debug, and deploy a simple COM+ "Hello World" application, using a traditional COM component and learning
about COM+ application types and configured components as you do so.
1.1 COM+ Component Services
Components need runtime services to work. The original COM runtime supported components located on the same machine,
typically a desktop PC. As the focus of Windows development shifted from standalone PCs to networked systems, Microsoft
found it necessary to add additional services (see The Evolution of COM+ Services). First, they added support for distributed
applications, or applications whose components are located on more than one machine (sometimes referred to as "COM on a
wire"). Later, Microsoft added new services to support enterprise applications, whose complexity and scale placed new
demands on the resources of a system and required an entirely new level of support. These trends were only exacerbated by
the move to web-based applications aimed at huge numbers of customers connected over the public Internet.
Collectively, the services that support COM and .NET component-based applications are known as the COM+ component
services, or simply as COM+.
The Evolution of COM+ Services

COM solved a number of problems facing early component developers by providing a binary standard for
components, defining a communication interface, and providing a way to link components dynamically. COM
freed developers from having to deal with "plumbing" and connectivity issues, allowing them to concentrate on
designing components.
By the mid-1990s, however, it was clear that Windows developers needed additional services to support
distributed and transaction-oriented applications. Distributed COM (DCOM) was released in 1995, a specification
and service used to distribute components across different machines and invoke them remotely. Then, Microsoft
released the Microsoft Transaction Server (MTS) in 1998, which provided component developers with new
services for transaction management, declarative role-based security, instance activation management,
component deployment and installation, and an administration tool for managing component configurations.
There was more to MTS than just new services. MTS represented a programming model in which the component
developer simply declared (using the MTS administrative tool) which services a component required, and left it
to MTS to provide an appropriate runtime environment. Developers could now spend even less effort on low-
level service plumbing (such as interacting with transaction processing monitors or managing the life cycle of an
object), and more on the business logic the customer paid for. Yet, MTS had its limitations. Foremost was the
fact that MTS was built on top of conventional COM/DCOM. The underlying operating system and COM itself
were unaware that MTS even existed. MTS resorted to esoteric hacks and kludges to provide its services, and
MTS could not provide its services to every COM object (multithreaded apartment objects were excluded). Some
services, such as object pooling, were either not possible or unavailable.
The development of a new version of the Windows NT operating system (initially called NT 5.0 and later
renamed Windows 2000), gave Microsoft an opportunity to correct the deficiencies of MTS and DCOM by fusing
them into a new comprehensive component services suite. Microsoft added yet more services, including object
pooling, queued components, and events, and made the package a part of the core Windows operating system.
The new suite of services was named COM+ 1.0, the subject of this book. The next version of COM+, COM+
1.5, is scheduled for release with Windows XP in Q4 2001 and is described in Appendix B.
The COM+ acronym is an overloaded and often misused term. Today it is used informally to refer to both the
latest version of the COM component specification and the component services available on the latest versions
of Windows. In this book, we use the term COM+ to refer to the COM+ component services. When we speak of
COM+ components, we refer to COM components configured to run under those services. However, as you will
see, a COM+ application may consist of either COM or .NET components (see COM+: The Migration Path

to .NET).
Page 7 of 238
10/3/2002file://F:\Documents%20and%20Settings\Administrator\Local%20Settings\Temp\Rar$EX0...
Here is a quick summary of the most important services provided by COM+:
Administration
Tools and services that enable programmers and administrators to configure and manage components and
component-based applications. The most important tool is the Microsoft Management Console Component Services
Explorer. COM+ also provides a standard location, the COM+ Catalog, for storing configuration information. The
Component Services Explorer is explained in the following section. The COM+ Catalog is described in Chapter 6.
Just-in-Time Activation (JITA)
Services that instantiate components when they are called and discard them when their work is done. JITA is
explained in Chapter 3.
Object pooling
Services that allow instances of frequently used, but expensive, resources, such as database connections, to be
maintained in a pool for use by numerous clients. Object pooling can improve the performance and responsiveness of
a distributed application dramatically. It is explained in Chapter 3.
Transactions
Services that allow operations carried out by distributed components and resources such as databases to be treated as
a single operation. Transaction management is a requirement of most commercial systems. COM+ Transaction
services are discussed in Chapter 4.
Synchronization
Services for controlling concurrent access to objects. These services are explained in Chapter 5.
Security
Services for authenticating clients and controlling access to an application. COM+ supports role-based security, which
is explained in Chapter 7.
Queued components
Services that allow components to communicate through asynchronous messaging, a feature that makes possible
loosely coupled applications or even disconnected applications. Queued components are discussed in Chapter 8.
Events
Services that allow components to inform one another of significant events, such as changes in data or system state.

COM+ supports a publish-subscribe model of event notification, which is described in Chapter 9.
To summarize, COM+ is about component services and has almost nothing to do with the way a component is developed.
The .NET framework allows you to develop binary components more easily than does COM, but it continues to rely on
component services available through COM+. The manner in which .NET and COM components are configured to use these
services, however, is not the same. Currently, most Windows enterprise developers are developing applications based on the
existing COM standard using Visual Basic 6 and Visual C++ 6 with ATL. For this reason, this book uses COM examples to
demonstrate COM+. However, these same services are available to .NET components as well. Chapter 10 shows you how to
use them.
COM+ 1.0 is an integral part of Windows 2000 and requires no special installation. Some COM+ features are available only
when both the client and server are running on Windows 2000 machines, but COM+ clients can usually run on Windows 9.x
and Windows NT machines as well.
Page 8 of 238
10/3/2002file://F:\Documents%20and%20Settings\Administrator\Local%20Settings\Temp\Rar$EX0...
When Windows XP is released in Q4 2001, it will include a new version of COM+ component services, COM+ 1.5. This new
version improves COM+ 1.0 usability and addresses some of the pitfalls of using COM+ 1.0 on Windows 2000, as described in
this book. COM+ 1.5 also adds new features to existing services and lays the foundation for integration with .NET web
services. Appendix B summarizes the forthcoming changes.
1.2 The Component Services Explorer
COM+ components and applications are managed through the Component Services Explorer (formerly known as the COM+
Explorer).The Component Services Explorer is a Microsoft Management Console snap-in and is available on every Windows
2000 machine.
To fire up the Component Services Explorer, go to the Start menu and select Settings Control Panel. When the Control
Panel window appears, select the Administrative Tools directory and then select the Component Services application.
The first thing you should do after locating the Component Services Explorer is create a shortcut to it on your desktop. As a
developer, you need easy access to the Component Services Explorer, your main gateway into COM+ (see Figure 1-1). You
can use the Component Services Explorer to create and configure COM+ applications, import and configure COM or .NET
components, export and deploy your applications, and administer your local machine. You can even administer COM+ on
other machines on the network, provided you have administrative privileges on those machines.
A COM+ application is a logical group of COM+ components. Components usually share an application if they depend on one
another to accomplish their tasks and when all the components require the same application level configuration, as with

security or activation policy. Components in the same application are often developed by the same team, and are meant to be
deployed together.
You can see all the COM+ applications installed on your machine by opening the Component Services Explorer and expanding
the Computers folder in the Tree window: Computers My Computer COM+ Applications. Every icon in the COM+
Applications folder represents a COM+ application. Each COM+ application contains COM+ components. Components must be
explicitly imported into the Component Services Explorer to take advantage of COM+ services.
The Component Services Explorer offers a hierarchical approach to managing COM+ services and configurations: a computer
contains applications, and an application contains components. A component has interfaces, and an interface has methods.
Each item in the hierarchy has its own configurable properties. Note that the hierarchy allows you to view the parameters of
any method listed in the hierarchy.
Figure 1-1. The Component Services Explorer
COM+: The Migration Path to .NET
.NET is Microsoft's next-generation component technology and application development platform. (For a quick
overview of the .NET platform, see Appendix C.) However, adopting a radically new technology such as .NET is
never an easy endeavor for companies and developers. Most have made a considerable investment in an
existing, often COM-based, code base and the developer skills needed to maintain it. Unless companies have a
compelling reason to move to .NET or a reasonable migration path, they postpone or avoid making the change.
However, because COM and .NET components can coexist in the same COM+ application, companies can
continue to build COM components today, adding .NET serviced components to their applications at a later time
when the advantages of doing so are more compelling. This is a migration strategy worth your consideration.
Page 9 of 238
10/3/2002file://F:\Documents%20and%20Settings\Administrator\Local%20Settings\Temp\Rar$EX0...

1.3 Hello COM+
The best way to become acquainted with the Component Services Explorer and basic COM+ terminology is to do a trivial
example. This section walks you through the COM+ equivalent of the canonical "Hello World" program. You will build a COM+
application containing a COM component that displays a message box saying "Hello COM+".
When developing your "Hello COM+" application, follow these steps:
1. Create a classic COM component. All COM+ components start their life as classic COM components, developed with
such tools as ATL, MFC, or Visual Basic 6.0.

2. Create a new COM+ application to host the component.
3. Add the component to the application.
4. Write a client and test the component.
The rest of this chapter uses this "Hello COM+" example to demonstrate various COM+ features and capabilities. The example
is also available as part of the source files provided with this book (see the Preface for information on how to access these
files).
1.3.1 Building a COM Component
We will use ATL 7.0 to generate a classic COM component, although you can also do it in Visual Basic 6.0 with almost the
same ease. Start a new ATL project in Visual Studio.NET and name it Hello. For simplicity, do not use Attributed project
(deselect Attributed in the ATL Project Wizard under Application Settings). Also, do not select COM+ 1.0 support. This
selection adds a few interfaces explained in subsequent chapters that are not relevant to this example. Bring up the Add Class
dialog ATL and select the Simple ATL Object item. This step should bring up the ATL Simple Object Wizard dialog (see Figure
1-2). Type the following entries, in order:
1. In the Short Name field, enter
Message
.
2. In the CoClass field, enter
Hello
.
Your completed dialog should look like Figure 1-2. There is no need to access the Options selection in the dialog (just use the
defaults). Click OK when you're done.
Figure 1-2. Use the ATL object wizard to generate a simple COM object
Page 10 of 238
10/3/2002file://F:\Documents%20and%20Settings\Administrator\Local%20Settings\Temp\Rar$EX0...

Right-click the IMessage interface icon in the Class View, and select Add and then Add Method... from the pop-up context
menu. This step brings up the Add Method Wizard. Enter ShowMessage as the method name and click OK.
After following these steps, the ATL Object Wizard will generate a new interface definition in the project IDL file, and the new
method wizard will add a method to that interface. Verify that the interface definition in the IDL file looks like this:
[

//various IDL attributes
]
interface IMessage : IDispatch
{
[id(1), helpstring("method ShowMessage")] HRESULT ShowMessage( );
};
Also make sure that the IDL file contains a type library section with the CoClass definition:
[
//you will have a different CLSID here:
uuid(C530E78E-9EE4-47D3-86CC-3B4EE39CBD26),
helpstring("Message Class")
]
coclass Hello
{
[default] interface IMessage;
};
Next, go to the message.cpp file and implement the
ShowMessage
( ) method of the
CMessage
class:
STDMETHODIMP CMessage::ShowMessage( )
{
::MessageBox(::GetActiveWindow( ),"Hello COM+","First COM+ Application",MB_OK);
return S_OK;
}
You can now compile and build the DLL. Every COM+ component must reside in a DLL, and that DLL must contain a type
library embedded in it as a resource. ATL will compile and build the DLL for you and add a reference to the type library in the
project resource file, the hello.rc file. COM+ does not require you to register your component, although the ATL build process
will register it for you. As you will see later, COM+ maintains its own components registration and configuration repository.

Page 11 of 238
10/3/2002file://F:\Documents%20and%20Settings\Administrator\Local%20Settings\Temp\Rar$EX0...