Transactional COM+: Building Scalable Applications

Aimed at the advanced C++ or Visual Basic programmer, Transactional COM+ explores the inner workings of Microsoft's COM+ components and provides expert tips and strategies for improving performance across the enterprise.

The most remarkable feature of this book is its extremely detailed guide to how COM+ components make use of system resources like contacts, threads, transactions, and objects. After providing in-depth background (and possible bottlenecks for each type of resource), the author provides a number of tips for better performance. Though sometimes densely written, this text will let COM+ component builders think about and get more performance. Snippets of code in C++ and Visual Basic show key concepts. The book also provides a handful of formulas to predict performance on a system using components.

There's plenty of expertise on display in this book for configuring and applying COM+ components using Microsoft Management Console (MMC) tools. Expert information on these tools is hard to find, and the author covers all the bases with options for pooling, transactions, and the like while recommending how to reduce the overhead of your components. You learn how to limit the use of contexts and transactions to improve performance when necessary. Sections on designing scalable applications on today's multitiered distributed architectures will help you plan for your next project. There's also advice for developing and testing distributed applications. A short appendix previews what's different on Microsoft's upcoming .NET platform (which supersedes the COM+ standard, but is backward-compatible).

In all, Transactional COM+ delivers what you need to become a truly advanced COM+ enterprise developer while making you think through performance and scalability issues on the Windows platform. For anyone faced with squeezing more performance out of existing hardware, the in-depth set of best practices and design expertise in this book will help you create leaner, meaner, and more scalable software. --Richard Dragan

Topics covered:

• Scalability basics in COM+
• Sharing identities remotely with COM objects
• The object-per-client model
• Transactions
• Processor objects
• Objects and contexts
• The COM+ catalog
• The Global Interface Table (GIT)
• Optimizing contexts (including raw-configured contexts)
• In-depth guide to threads and apartments (including activities and apartment types)
• Object pooling (including reusing objects and guidelines)
• Just-in-Time (JIT) activation objects
• Transactions (including local and distributed transactions, transaction streams, and declarative transactions)
• Isolation levels and performance (including deadlocks and timeouts)
• Optimistic and pessimistic application-level locking
• Performance issues with common protocols (HTTP, ASPs, SOAP, and message queuing)
• Designing scalable systems (including machine and process architecture)
• Processor and helper objects
• Managing middle-tier state
• Performance tips
• Introduction to .NET used with COM+
• Pooled connections
• Debugging
• Catalog attributes and COM+ administration tools