Combining JITA with Object Pooling
The
two instance management techniques
provided by COM+ are not mutually exclusive. JITA and object pooling
can be combined in a very powerful way. Using both object pooling and
JITA on the same component is useful in situations when object
initialization is both generic (not client specific) and expensive.
Thus, using just JITA would not make sense; when you have no control
over the length of time, the object’s client keeps its
reference to the object, so you would realize marginal gain from
object pooling. When you configure your object to use both, instead
of creating and releasing the object on each method call, COM+ grabs
an object from the pool and returns the object to the pool after the
method completes its execution. The JITA aspects are still maintained
because the object instance will be torn away from its client. The
pool will also be used on every method call, not just on
CoCreate
and Release
calls from
the client. Implementing IObjectControl
is
optional, but I strongly recommend it. As always, a call to
IObjectControl::Activate( )
marks entry to a
context, and a call to IObjectControl::Deactivate( )
marks an exit. COM+ calls
IObjectControl::CanBePooled( )
after every
Deactivate( )
, letting the object decide whether
it wants to be recycled or destroyed. This life cycle is shown in
Figure 3-9. When you configure your component to support both JITA and object pooling, COM+ deactivates the object every time the done bit is set and returns ...
Get COM & .NET Component Services now with the O’Reilly learning platform.
O’Reilly members experience books, live events, courses curated by job role, and more from O’Reilly and nearly 200 top publishers.