ArcGIS Engine Developer Guide

THE MICROSOFT COMPONENT OBJECT MODEL
All ActiveX controls support IDispatch. This means it is possible to use the various
ActiveX controls shipped with ArcObjects to access functionality from
within scripting environments.
Interfaces that directly inherit from an interface
other than IUnknown cannot be implemented
in VB.
COM
containment
COM
aggregation
Custom
feature
interface1
interface2
child class
parent class
interface1
interface2
interface1
interface2
interface3
interface4
IUnknown
class
method3
method4
IUnknown
class
method1
method2
IUnknown (controlling)
class
IUnknown (inner)
class
method1
method2
method3
method4
IUnknown
feature
method7
method8
IUnknown
class
method3
method4
method1
method2
method5
method6
INTERFACE INHERITANCE
An interface consists of a group of methods and properties. If one interface
inherits from another, then all the methods and properties in the parent are
directly available in the inheriting object.
The underlying principle here is interface inheritance, rather than the implementation
inheritance you may have seen in languages such as SmallTalk and C++. In
implementation inheritance, an object inherits actual code from its parent; in
interface inheritance, it’s the definitions of the methods of the object that are
passed on. The coclass that implements the interfaces must provide the implementation
for all inherited interfaces.
Implementation inheritance is not supported in a heterogeneous development
environment because of the need to access source and header files. For reuse of
code, COM uses the principles of aggregation and containment. Both of these are
binary-reuse techniques.
AGGREGATION AND CONTAINMENT
For a third-party developer to make use of existing objects, using either containment
or aggregation, the only requirement is that the server housing the contained
or aggregated object is installed on both the developer and target release machines.
Not all development languages support aggregation.
The simplest form of binary reuse is containment. Containment allows modification
of the original object’s method behavior but not the method’s signature.
With containment, the contained object (inner) has no knowledge that it is
contained within another object (outer). The outer object must implement all the
interfaces supported by the inner. When requests are made on these interfaces,
the outer object simply delegates them to the inner. To support new functionality,
the outer object can either implement one of the interfaces without passing the
calls on or implement an entirely new interface in addition to those interfaces
from the inner object.
COM aggregation involves an outer object that controls which interfaces it
chooses to expose from an inner object. Aggregation does not allow modification
of the original object’s method behavior. The inner object is aware that it is being
aggregated into another object and forwards any QueryInterface calls to the outer
(controlling) object so the object as a whole obeys the laws of COM.
To the clients of an object using aggregation, there is no way to distinguish which
interfaces the outer object implements and which interfaces the inner object
implements.
Custom features make use of both containment and aggregation. The developer
aggregates the interfaces where no customizations are required and contains those
that are to be customized. The individual methods on the contained interfaces can
then either be implemented in the customized class, thus providing custom functionality,
or the method call can be passed to the appropriate method on the contained
interface.
66 • ArcGIS Engine Developer Guide