Transactional COM+: Building Scalable Applications

Tim Ewald

  • 出版商: Addison Wesley
  • 出版日期: 2001-03-16
  • 售價: $1,398
  • 貴賓價: 9.5$1,328
  • 語言: 英文
  • 頁數: 464
  • 裝訂: Paperback
  • ISBN: 0201615940
  • ISBN-13: 9780201615944
  • 相關分類: JVM 語言
  • 立即出貨(限量) (庫存=4)




Transactional COM+ explains how COM+ works and shows students how to use the technology to its fullest potential as a framework for developing scalable applications. It examines the theory behind COM+, why traditional object-oriented models are inappropriate for scalable systems, and the importance of transactions. This book goes beyond the rationale behind the technology and the details of its implementation to present practical, concrete guidelines for using COM+ to build applications that scale.

Back to Top

Table Of Contents

1. Scalability.
Scalability Basics.
Identity in COM.
Sharing Identities.
Implementing Named Objects.
The Problem with Sharing COM Objects.

Identity Revisited.
Implementing Named Objects with Key-Based Logical Identity.
Implementing Named Objects on Top of a Database.
What Has Been Gained?

The Object-per-Client Model.
Enter Transactions.
Clients and TMs and RMs, Oh My!
Local Transactions and Distributed Transactions.
The Transactions and Scalability Paradox.

Integrating Objects and Transactions.
Using Transactions Explicitly.
Using Transactions Implicitly.
Applying Transactions.
Thinking about Roundtrips.

A Complex Problem.
A Possible Solution.
A Much Better Solution.
Thinking about Roundtrips Again.
Processor Objects.


2. Atoms.
The Linker Switch Story.
An Experiment.
The Windows Process Loader.
How COM+ Works.

From Consoles to Contexts.
Cross-Context Calls.

Contexts as Objects.
Object Context Interfaces.
Using Object Context.

Where Do Contexts Come From?
The Catalog.
Libraries and Servers.
Why Library Applications?
Configured Classes.
Custom Attributes.
Changing the Contents of the Catalog.

Context Flow.
How Causality Works.

Causalities as Objects.
Call Context Interfaces.
Using Call Context.


3. Mechanics.
Context Relativity.
The Problem.
Marshaling Interface Pointers.
The Global Interface Table.
Context Relativity in Day-to-Day Life.

The Cost of Contexts.
A Context for Every Object.
The Cost of Contexts in Time.
The Cost of Contexts in Space.
Are Contexts Worth the Price?

Limiting Context.
Nonconfigured Classes.
Raw-Configured Classes.
Context-Aware Code Revisited.
A Different Way of Looking at the World.
Subtle Complexities.
Custom Marshaling.

Some Other Observations.

4. Threads.
Apartment Types.
Where Do Apartments Come From?
Threading Models.
Default Contexts.
Remote Object Creation.

Cross-Apartment Calls.
STA Complexities.
Cross-Apartment Call Overhead.

Apartment Guidelines.
Raw-Configured Classes Revisited.

Enter Activities.
Where Do Activities Come From?
Detecting the Presence of an Activity.

Allocating STA Objects to Apartments.
Serializing Calls.
Activity Reentrancy.
Activity Deadlock.

Activity Guidelines.

5. Objects.
Object Pooling.
Enabling Object Pooling.
Reusing Objects.
Controlling the Size of a Class's Pool.

Implementing Pooled Classes.
Accessing Context.
Managing Resources.
The GIT Trick (and Why It Doesn't Work).
An Exception to the Rules.

Object Pooling Guidelines.
Just-in-Time Activation.
Enabling JITA.
How JITA Works.
Flipping the Done Bit.
The AutoComplete Attribute.
JITA Notifications.

JITA Guidelines.
Lies, Damn Lies, and Statistics.

6. Transactions.
Local Transactions.
Higher Level APIs.

Distributed Transactions.
Enter the Distributed Transaction Coordinator.
Starting a Distributed Transaction.
Enlisting a Connection.
The Two-Phase Commit Protocol.

Distributed Transaction Complexities.
Distributed Transaction Propagation.
Connection Management.
A Race Condition.

Declarative Transactions.
Transactional Objects.
Enter Transaction Streams.
Where Do Transaction Streams Come From?
Detecting the Presence of a Transaction Stream.
Creating and Propagating a Distributed Transaction.
Autoenlisting Connections.
Controlling a Declarative Transaction's Outcome.
Flipping the Happy Bit.
The Four Possible States of a Transactional Object.
Root Objects and HRESULTs.
Transaction Stream Caveats.

Transaction Guidelines.

7. Isolation.
Correctness versus Performance.
Five Degrees of Isolation.
Implementing Isolation Using Locks.
Implementing Isolation Using Versions.
Choosing an Isolation Level.
Isolation-Level Guidelines.

Specifying Isolation Levels.
Isolation Levels and OLE DB.
Isolation Levels and the DTC.
Isolation Levels and COM+.
Bring Your Own Transaction.

Avoiding Deadlocks.
Detecting Deadlocks.
Timeouts and the DTC.
Timeouts and COM+.
Timeouts and OLE DB.

Application-Level Isolation.
Optimistic Application-Level Locking.
Pessimistic Application-Level Locking.


8. Protocols.
HTTP Messages.
HTTP Connection Management.

Internet Information Server.
Mapping Requests to Files.
Mapping Requests to Processes.
Mapping Requests to Contexts and Apartments.
Processing Requests in Parallel.

Active Server Pages.
Processing ASP Requests.
Transactional Pages.
Transaction Outcome Notifications.
Server.Execute and Server.Transfer.
ASP Pages and Raw-Configured Classes.
ASP Pages and Object Context.

SOAP Messages.
Applying SOAP.

Message Queuing.
Transactional Messaging.
Applying Message Queuing.


9. Design.
Machines, Processes, and Protocols.
Machine Architecture.
Process Architecture.

Processors and Helpers.
A Simple Logical Model.
A Simple Physical Model.
Accessing Processors via HTTP.

Transactions and Data Access.
Accessing Data Efficiently.

Middle-Tier State.
Some Final Advice.

Appendix A: Toward .NET.
Appendix B: Building a Better Connection Pool.
An Example.
Using a Pooled Connection.
Source Code.

Appendix C: Debugging.
Appendix D: Catalog Attributes and Component Services Explorer Property Pages.
Application Property Pages.
Class Property Pages.
Interface Property Pages.
Method Property Pages.

Index. 0201615940T04062001

Back to Top


《Transactional COM+》解釋了COM+的工作原理,並向讀者展示如何充分利用這項技術作為開發可擴展應用程式的框架。本書探討了COM+背後的理論,傳統的物件導向模型為何不適用於可擴展系統,以及交易的重要性。本書不僅闡述了技術背後的原理和實現細節,還提供了使用COM+建立可擴展應用程式的實用指南。

1. 可擴展性
2. 原子
3. 機制
4. 執行緒