1. Chapter 1 COM+ Component Services

   1. COM+ Component Services

   2. The Component Services Explorer

   3. Hello COM+

   4. COM+ Configured Components

   5. Applications, DLLs, and Components

   6. Configuring COM+ Applications

   7. Debugging COM+ Applications

   8. Deploying COM+ Applications

   9. Summary

2. Chapter 2 COM+ Context

   1. Encapsulation via Marshaling in COM

   2. Encapsulation via Interception in COM+

   3. The Context Object

   4. The Call Object

   5. Cross-Context Manual Marshaling

   6. Summary

3. Chapter 3 COM+ Instance Management

   1. Client Types

   2. Instance Management and Scaling

   3. Object Pooling

   4. Just-in-Time Activation

   5. Combining JITA with Object Pooling

   6. Object Constructor String

   7. COM+ Instance Management Pitfalls

4. Chapter 4 COM+ Transactions

   1. Transaction Basics

   2. Transaction Properties

   3. Transaction Scenarios

   4. COM+ Transactions Architecture

   5. Configuring Transactions

   6. Voting on a Transaction

   7. Transactional Object Life Cycle

   8. Designing Transactional Components

   9. Nontransactional Clients

   10. Transactions and Object Pooling

   11. Compensating Transactions

   12. Transaction Execution Time

   13. Tracing Transactions

   14. In-Doubt Transactions

   15. Transaction Statistics

   16. COM+ Transactions Pitfalls

5. Chapter 5 COM+ Concurrency Model

   1. Object-Oriented Programming and Multiple Threads

   2. Apartments: The Classic COM Solution

   3. Activities: The COM+ Innovation

   4. COM+ Configuration Settings

   5. Activities and JITA

   6. Activities and Transactions

   7. Tracing Activities

   8. The Neutral Threaded Apartment

   9. Summary

6. Chapter 6 Programming the COM+ Catalog

   1. Why Program the Catalog?

   2. The Catalog Programming Model

   3. Catalog Structure

   4. Interacting with the Catalog

   5. Features of COMAdminCatalog

   6. The COM+ Catalog and Transactions

   7. Summary

7. Chapter 7 COM+ Security

   1. The Need for Security

   2. Basic Security Terms

   3. Role-Based Security

   4. Securing a Server Application

   5. Securing a Library Application

   6. Programmatic Role-Based Security

   7. Security Boundaries

   8. Advanced COM+ Security

   9. COM+ Security Pitfalls

   10. Summary

8. Chapter 8 COM+ Queued Components

   1. Major Benefits of Queued Components

   2. Queued Components Architecture

   3. Component Services Explorer Configuration

   4. Invoking Queued Components on the Client Side

   5. Designing Queued Component Interfaces

   6. Receiving Output from a Queued Component

   7. Queued Component Error Handling

   8. Queued Components and Transactions

   9. Synchronous Versus Asynchronous Components

   10. Queued Components Security

   11. Queued Components Pitfalls

   12. Summary

9. Chapter 9 COM+ Event Service

   1. Classic COM Events

   2. COM+ Event Model

   3. The Event Class

   4. Subscription Types

   5. Delivering Events

   6. Event Filtering

   7. Distributed COM+ Events

   8. Asynchronous Events

   9. COM+ Events and Transactions

   10. COM+ Events and Security

   11. COM+ Events Limitation

   12. Summary

10. Chapter 10 .NET Serviced Components

    1. Developing Serviced Components

    2. .NET Assemblies and COM+ Applications

    3. Registering Assemblies

    4. Configuring Serviced Components

    5. Application Activation Type

    6. The Description Attribute

    7. Accessing the COM+ Context

    8. COM+ Context Attributes

    9. COM+ Object Pooling

    10. COM+ Just-in-Time Activation

    11. COM+ Constructor String

    12. COM+ Transactions

    13. COM+ Synchronization

    14. Programming the COM+ Catalog

    15. COM+ Security

    16. COM+ Queued Components

    17. COM+ Loosely Coupled Events

    18. Summary

1. Appendix A The COM+ Logbook

   1. Logbook Requirements

   2. Log File Example

   3. Using the Logbook

   4. Configuring the Logbook

   5. How Does the Logbook Work?

   6. Summary

2. Appendix B COM+ 1.5

   1. Improved User Interface Usability

   2. Legacy Applications and Components

   3. Disabling Applications and Components

   4. Pausing Applications

   5. Service Activation Type

   6. Improved Queuing Support

   7. Application Pooling and Recycling

   8. Application Dump

   9. Application Partitioning

   10. Aliasing Components

   11. Configurable Transaction Isolation Level

   12. Improved Context Activation Setting

   13. Private Components

   14. Web Services in COM+ 1.5

   15. Summary

3. Appendix C Introduction to .NET

   1. .NET Programming Languages

   2. Packaging .NET Components: Assemblies

   3. Developing .NET Components

   4. Writing .NET Client-Side Code

   5. .NET as a Component Technology

   6. Composing Assemblies

4. Colophon

Our look is the result of reader comments, our own experimentation, and feedback from distribution channels. Distinctive covers complement our distinctive approach to technical topics, breathing personality and life into potentially dry subjects. The animals on the cover of COM and .NET Component Services are moray and conger eels. Eels make up the 10 families of fish belonging to the order Arguilliformes. Known for their snakelike body with no hind fins, eels can move through water, mud, and rocky crevices. Most eels are less than three feet long, but freshwater conger eels can grow as large as nine feet. Until the 20th century, little was known about the life cycle and migration of eels. Scientists now know that American and European eels travel long distances during their reproductive cycles. The female eels generally mature in freshwater lakes and travel to the nearest ocean, often slithering over wet grass and mud during the journey. Then they swim or drift from Europe or North America to the Sargasso Sea. There, the females lay up to 20 million eggs and then die. The egg-larvae then drift either to North America (after one year) or back to Europe (after three years). After reaching their home continent, the eels complete their cycle by gathering at the mouths of rivers and swimming upstream. Eels are also known for their oily meat, cherished by some as a culinary delicacy. Ann Schirmer was the production editor for COM and .NET ComponentServices. Paulette Miley and Ann Schirmer were the copyeditors for the book. Ann Schirmer and Leanne Soylemez were the proofreaders. Claire Cloutier, Mary Brady, and Rachel Wheeler provided quality control. Kimo Carter, Ann Schirmer, and Sarah Sherman did interiorcomposition. Judy Hoer wrote the index.

Ellie Volckhausen 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 Archive. Emma Colby produced the cover layout with QuarkXPress 4.1 using Adobe's ITC Garamond font.

David Futato designed the interior layout. Neil Walls converted the files from Microsoft Word to FrameMaker 5.5.6 using tools created by Mike Sierra. The text font is Linotype Birka, the heading font is Adobe Myriad Condensed, and the code font is LucasFont's TheSans Mono Condensed. The illustrations that appear in the book were produced by Robert Romano and Jessamyn Read using Macromedia FreeHand 9 and Adobe Photoshop 6. The tip and warning icons were drawn by Christopher Bing. This colophon was written by Ann Schirmer.

Whenever possible, our books use a durable and flexible lay-flat binding.