- STAFF PICKS
- GIFTS + GIFT CARDS
- SELL BOOKS
- FIND A STORE
Used Trade Paper
Ships in 1 to 3 days
More copies of this ISBN
Other titles in the DevelopMentor series:
Transactional COM+ - Building Scalable Applicationsby Tim Ewald
Synopses & Reviews
Building scalable distributed systems that efficiently perform enterprise-critical functions is incredibly challenging. Microsoft developed COM+ to help. COM+ is a sophisticated runtime environment for COM components. It is designed to make the development of scalable systems easier and is the foundation for higher-level frameworks such as BizTalk and Site Server Commerce Edition. But you can't use COM+ effectively if you don't understand how it works.
Transactional COM+ explains how COM+ works and shows readers how to use the technology to its fullest potential as a framework for developing scalable applications. It examines the theory behind COM+, including the nature of scalability, why traditional object-oriented models are inappropriate for scalable systems, and the importance of transactions. The book explores how the two basic atoms of context and causality are used to implement COM+ runtime services. It introduces apartments and activities and the role they play in controlling concurrency in a COM+ process. It also introduces transaction streams and explains how they are used to integrate objects and transactions. Ewald shows how just-in-time activation and object pooling together change the relationship between a client and an object and reveals the importance of HTTP and MSMQ as communication protocols that offer significant advantages over DCOM. Most important, the author explains the influence all these factors have on the design of scalable COM+-based systems.
Practical in its approach, Transactional COM+ goes beyond the rationale behind the technology and the details of its implementation to present concrete guidelines for using COM+ to build applications that scale.
Book News Annotation:
This text for system developers explains how COM+ works and shows how to use the technology as a framework for developing scalable applications. Scalable systems researcher Ewald examines theoretical issues, including the nature of scalability, why traditional object- oriented models are inappropriate for scalable systems, and the importance of transactions. Coverage extends to context and causality in the implementation of COM+ runtime services, the role of apartments and activities in controlling concurrency in a COM+ process, transaction streams, just-in-time activation, and object pooling. Readers should posses some basic knowledge of COM classes, simple ASP pages, the COM+ and IIS administration tools, the Component Services Explorer (CSE) and the Internet Services Manager.
Annotation c. Book News, Inc., Portland, OR (booknews.com)
Tim Ewald, COM columnist for DOC Magazine, explains how COM+ works, and then sets out specific rules intended as concrete guidelines to help developers build COM+ systems.
About the Author
Tim Ewald is a Director of Content at DevelopMentor, a premier developer services company. His research and development work focuses on the design and implementation of scalable systems using component technologies such as COM and Java. Tim has authored or co-authored several DevelopMentor courses, including the MTS and COM+ curriculum. He is also a co-author of Effective COM (Addison-Wesley), a former columnist for DOC and Application Strategies, and a frequent conference speaker. Before joining DevelopMentor, Tim worked as an independent consultant specializing in COM and related technologies.
Table of Contents
Identity in COM.
Implementing Named Objects.
The Problem with Sharing COM Objects.
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.
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.
Thinking about Roundtrips.
A Complex Problem.
A Possible Solution.
A Much Better Solution.
Thinking about Roundtrips Again.
The Linker Switch Story.
The Windows Process Loader.
How COM+ Works.
From Consoles to Contexts.
Contexts as Objects.
Object Context Interfaces.
Using Object Context.
Where Do Contexts Come From?
Libraries and Servers.
Why Library Applications?
Changing the Contents of the Catalog.
How Causality Works.
Causalities as Objects.
Call Context Interfaces.
Using Call Context.
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?
Context-Aware Code Revisited.
A Different Way of Looking at the World.
Some Other Observations.
Where Do Apartments Come From?
Remote Object Creation.
Cross-Apartment Call Overhead.
Raw-Configured Classes Revisited.
Where Do Activities Come From?
Detecting the Presence of an Activity.
Allocating STA Objects to Apartments.
Enabling Object Pooling.
Controlling the Size of a Class's Pool.
Implementing Pooled Classes.
The GIT Trick (and Why It Doesn't Work).
An Exception to the Rules.
Object Pooling Guidelines.
How JITA Works.
Flipping the Done Bit.
The AutoComplete Attribute.
Lies, Damn Lies, and Statistics.
Higher Level APIs.
Enter the Distributed Transaction Coordinator.
Starting a Distributed Transaction.
Enlisting a Connection.
The Two-Phase Commit Protocol.
Distributed Transaction Complexities.
Distributed Transaction Propagation.
A Race Condition.
Enter Transaction Streams.
Where Do Transaction Streams Come From?
Detecting the Presence of a Transaction Stream.
Creating and Propagating a Distributed Transaction.
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.
Correctness versus Performance.
Five Degrees of Isolation.
Implementing Isolation Using Locks.
Implementing Isolation Using Versions.
Choosing an Isolation Level.
Specifying Isolation Levels.
Isolation Levels and OLE DB.
Isolation Levels and the DTC.
Isolation Levels and COM+.
Bring Your Own Transaction.
Timeouts and the DTC.
Timeouts and COM+.
Timeouts and OLE DB.
Optimistic Application-Level Locking.
Pessimistic Application-Level Locking.
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.
Transaction Outcome Notifications.
Server.Execute and Server.Transfer.
ASP Pages and Raw-Configured Classes.
ASP Pages and Object Context.
HTTP + XML = RPC.
SOAP and HTTP.
Applying Message Queuing.
Machines, Processes, and Protocols.
Processors and Helpers.
A Simple Logical Model.
A Simple Physical Model.
Accessing Processors via HTTP.
Transactions and Data Access.
Accessing Data Efficiently.
Some Final Advice.
Appendix A: Toward .NET.
Appendix B: Building a Better Connection Pool.
Using a Pooled Connection.
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.
What Our Readers Are Saying
Other books you might like
Computers and Internet » Computers Reference » General