This is Real Life Sale
 
 

Special Offers see all

Enter to WIN a $100 Credit

Subscribe to PowellsBooks.news
for a chance to win.
Privacy Policy

Visit our stores


    Recently Viewed clear list


    Original Essays | February 15, 2015

    Jennifer Jacquet: IMG Is Shame Necessary?



    Is Shame Necessary? is my first book, so I am far from having earned the right to discuss writing a book in general. But I can say something about... Continue »

    spacer
Qualifying orders ship free.
$5.50
List price: $45.50
Used Trade Paper
Ships in 1 to 3 days
Add to Wishlist
Qty Store Section
1 Local Warehouse Microsoft Windows- Programming

More copies of this ISBN

Transactional COM+ - Building Scalable Applications

by

Transactional COM+ - Building Scalable Applications Cover

 

Synopses & Reviews

Publisher Comments:

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.

0201615940B04062001

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)

Synopsis:

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.

0201615940AB04062001

Table of Contents

1. Scalability.

Scalability Basics.

Identity.

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.

Transactions.

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.

Summary.

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.

Applications.

Libraries and Servers.

Why Library Applications?

Configured Classes.

Custom Attributes.

Changing the Contents of the Catalog.

Context Flow.

Causality.

How Causality Works.

Causalities as Objects.

Call Context Interfaces.

Using Call Context.

Summary.

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.

Summary.

4. Threads.

Apartments.

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.

Activities.

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.

Summary.

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.

Summary.

6. Transactions.

Local Transactions.

OLE DB.

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.

Summary.

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.

ISOFLAGs.

Deadlocks.

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.

Summary.

8. Protocols.

HTTP.

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.

HTTP + XML = RPC.

SOAP Messages.

SOAP and HTTP.

Applying SOAP.

Message Queuing.

Transactional Messaging.

Applying Message Queuing.

Summary.

9. Design.

Machines, Processes, and Protocols.

Machine Architecture.

Process Architecture.

Protocols.

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.

IObjectConstruct.

IObjectControl.

IConn.

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.

Rules.

Summary.

Index. 0201615940T04062001

Product Details

ISBN:
9780201615944
Author:
Ewald, Tim
Publisher:
Addison-Wesley Professional
Location:
Boston, MA
Subject:
Programming - General
Subject:
Programming - Object Oriented Programming
Subject:
Client-server computing
Subject:
COM (Computer architecture)
Subject:
Microsoft Transaction Server.
Subject:
COM
Subject:
Data processing
Subject:
Software Engineering-Object Oriented Programming
Copyright:
Edition Description:
Trade paper
Series:
The developMentor series
Series Volume:
v. 19, no. 2
Publication Date:
March 2001
Binding:
TRADE PAPER
Grade Level:
Professional and scholarly
Language:
English
Illustrations:
Yes
Pages:
464
Dimensions:
9.20x7.16x1.08 in. 1.73 lbs.

Other books you might like

  1. Monte Carlo Methods in Finance... New Hardcover $155.75

Related Subjects

Computers and Internet » Computers Reference » General
Computers and Internet » Operating Systems » Microsoft Windows » Programming
Computers and Internet » Operating Systems » Microsoft Windows » Win32 Programming
Computers and Internet » Software Engineering » General
Computers and Internet » Software Engineering » Object Oriented Programming

Transactional COM+ - Building Scalable Applications Used Trade Paper
0 stars - 0 reviews
$5.50 In Stock
Product details 464 pages PEARSON EDUCATION - English 9780201615944 Reviews:
"Synopsis" by , 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.
spacer
spacer
  • back to top

FOLLOW US ON...

     
Powell's City of Books is an independent bookstore in Portland, Oregon, that fills a whole city block with more than a million new, used, and out of print books. Shop those shelves — plus literally millions more books, DVDs, and gifts — here at Powells.com.