The process of loading an object in memory, which puts it into its running state. See also Binding.
A moniker that specifies the absolute location of an object. An absolute moniker is analogous to a full path. See also Moniker.
A COM object that caches, manages, and sends notifications of changes to container applications' advisory sinks. See also Advisory sink.
A COM object that can receive notifications of changes in an object
because it implements the
Containers that need to be notified of changes in objects
implement an advisory sink.
Notifications originate in the server, which uses
an advisory holder object to cache and manage notifications to containers.
See also Advisory holder.
A COM object that is made up of one or more other COM objects.
in the aggregate is designated the controlling object, which controls which
interfaces in the aggregate are exposed and which are private.
object has a special implementation of
All objects in the aggregate
must pass calls to
methods through the controlling
A composition technique for implementing COM objects. It allows you to build a new object by reusing one or more existing objects' interface implementations. The aggregate object chooses which interfaces to expose to clients, and the interfaces are exposed as if they were implemented by the aggregate object. Clients of the aggregate object communicate only with the aggregate object. See also Aggregate object. Contrast with Containment.
The inverse of a file, item, or pointer moniker. An anti-moniker is added to the end of a file, item, or pointer moniker to nullify it. Anti-monikers are used in the construction of relative monikers. See also Relative Moniker.
Artificial reference counting
A technique used to safeguard an object before calling a function or
method that could prematurely destroy it.
A program calls
to increment the object's reference count before making the call
that could free the object.
After the function returns, the program calls
to decrement the count.
A call to a function that is executed separately so that the caller can continue processing instructions without waiting for the function to return. Contrast with Synchronous call.
A way to manipulate an application's objects from outside the application. Automation is typically used to create applications that expose objects to programming tools and macro languages, create and manipulate one application's objects from another applications, or to create tools for accessing and manipulating objects.
A COM object that implements the
Bind contexts are used in moniker operations to hold references to the objects
activated when a moniker is bound.
The bind context contains parameters that
apply to all operations during the binding of a generic composite moniker
and provides the moniker implementation with access to information about its
See also Binding, Generic composite moniker,
Associating a name with its referent. Specifically, locating the object named by a moniker, putting it into its running state if it isn't already, and returning an interface pointer to it. Objects can be bound at run time (also called late binding or dynamic binding) or at compile time (also called static binding). See also Moniker and Running state.
The definition of an object in code. In C++, the class of an object is defined as a data type, but this is not the case in other languages. Because COM can be coded in any language, class is used to refer to the general object definition. See also Class factory.
A COM object that implements the
and that creates one or more instances of an object identified by a given
See also Class identifier.
Class identifier (CLSID)
A globally unique identifier (GUID) associated with an COM class object. If a class object will be used to create more than one instance of an object, the associated server application should register its CLSID in the system registry so that clients can locate and load the executable code associated with the object(s). Every COM server or container that allows linking to its embedded objects must register a CLSID for each supported object definition. See also Class and Class factory.
In object-oriented programming, an object whose state is shared by all the objects in a class and whose behavior acts on that classwide state data. In COM, class objects are called class factories, and typically have no behavior except to create new instances of the class. See also Class factory.
A COM object that requests services from another object.
See Class identifier.
To persistently save any changes made to a storage or stream object since it was opened or changes were last saved. See also Revert.
An object that encapsulates both data and code, and provides a well-specified set of publicly available services.
Component Object Model (COM)
The object-oriented programming model that defines how objects interact within a single process or between processes. In COM, clients have access to an object through interfaces implemented on the object. See also Interface.
A moniker that consists of two or more monikers that are treated as a unit. A composite moniker can be non-generic, meaning that its component monikers have special knowledge of each other, or generic, meaning that its component monikers know nothing about each other except that they are monikers.See also Generic composite moniker.
An object that conforms to the Component Object Model (COM). A COM object is an instance of an object definition, which specifies the object's data and one or more implementations of interfaces on the object. Clients interact with a COM object only through its interfaces. See also Component Object Model and Interface.
A COM object that implements, at a minimum, the
interface, for the management of connection point objects.
objects support communication from the server to the client.
object creates and manages one or more connection point subobjects, which
receive events from interfaces implemented on other objects and send them
on to the client.
Connection point object and
Connection point object
A COM object that is managed by a connectable object and that implements
One or more connection
point objects can be created and managed by a connectable object.
point object manages incoming events from a specific interface on another
object and sends those events on to the client.
See also Connectable
object, Advisory sink.
A composition technique for implementing COM objects. It allows one object to reuse some or all of the interface implementations of one or more other objects. The outer object acts as a client to the other objects, delegating implementation when it wishes to use the services of one of the contained objects. Contrast with Aggregation.
The object within an aggregate object that controls which interfaces
within the aggregate object are exposed and which are private.
interface of the controlling object is called the controlling
methods of other
objects in the aggregate must be passed to the controlling
See also Aggregate object.
Data transfer object
An object that implements the
and contains data to be transferred from one object to another through either
the Clipboard or drag-and-drop operations.
A COM object that is typically initialized by another object (the
Although the dependent object's lifetime may only
make sense during the lifetime of the host object, the host object does not
function as the controlling
for the dependent
In contrast, an object is an
when its lifetime (by means of its reference count) is completely controlled
by the managing object.
Contrast with Aggregation and Containment.
Direct access mode
One of two access modes in which a storage object can be opened. In direct mode, all changes are immediately committed to the root storage object. See also Transacted access mode.
See Out-of-process server.
A moniker based on a path in the file system.
File monikers can be used
to identify objects that are saved in their own files.
A file moniker is a
COM object that supports the system-provided implementation of the
interface for the file moniker class.
See also Item moniker, Generic composite moniker, and Moniker.
A GUID that identifies a persistent property set. Also referred to as FMTID. See also Property set.
Generic composite moniker
A sequenced collection of monikers, starting with a file moniker to provide the document-level path and continuing with one or more item monikers that, taken as a whole, uniquely identifies an object. See also Composite moniker, Item moniker, and File moniker.
A function that encapsulates calls to other functions and interface methods publicly available in COM. Helper functions are a convenient way to call frequently used sequences of function and method calls that accomplish common tasks.
A COM object that forms a hierarchical relationship with one or more
other COM objects, known as the
the host object instantiates the dependent objects, and their existence only
makes sense within the lifetime of the host object.
However, the host object
does not act as the controlling
for the dependent
objects, nor does it directly delegate to the interface implementations of
A parameter that is allocated, set, and freed by the caller of a function or interface method. An In parameter is not modified by the called function. See also In/Out parameter and Out parameter.
A parameter that is initially allocated by the caller of a function or interface method, and set, freed, and reallocated, if necessary, by the process that is called. See also In parameter and Out parameter.
A server implemented as a DLL that runs in the process space of the client. See also Out-of-process server, Local server, and Remote server.
An object for which memory is allocated or which is persistent.
A group of semantically related functions that provide access to a COM object. Each COM interface defines a contract that allows objects to interact according to the Component Object Model (COM). While COM provides many interface implementations, most interfaces can also be implemented by developers designing COM applications. See also Component Object Model and COM object.
Interface identifier (IID)
A globally unique identifier (GUID) associated with an interface. Some functions take IIDs as parameters to allow the caller to specify which interface pointer should be returned.
A moniker based on a string that identifies an object in a container. Item monikers can identify objects smaller than a file, including embedded objects in a compound document, or a pseudo-object (like a range of cells in a spreadsheet). See also File moniker, Generic composite moniker, Moniker, and Pseudo-object.
A feature of COM that provides control over object creation.
objects can be created only by clients that are authorized to use them.
is implemented in COM through the
and by support for a license key that can be passed at run time.
The data that is the source of a linked object. A link source may be a file or a portion of a file, such as a selected range of cells within a file (also called a pseudo object). See also Linked object.
The state of an object after its data structures have been loaded into memory and are accessible to the client process. See also Active state, Passive state, and Running state.
An out-of-process server implemented as an .EXE application running on the same machine as its client application. See also In-process server, Out-of-process server, and Remote server.
A pointer held to-and possibly, a reference count incremented on-a running
COM defines two types of locks that can be held on an object:
To implement a strong lock,
a server must maintain both a pointer and a reference count, so that the object
will remain "locked" in memory at least until the server calls
To implement a weak lock, the server maintains only a pointer
to the object, so that the object can be destroyed by another process.
Packaging and sending interface method calls across thread or process boundaries.
An object that implements the
A moniker acts as a name that uniquely identifies a COM object.
In the same
way that a path identifies a file in the file system, a moniker identifies
a COM object in the directory namespace.
An implementation of the
moniker classes include file monikers, item monikers, generic composite monikers,
anti-monikers, pointer monikers, and URL monikers.
An application that uses monikers to acquire interface pointers to objects managed by another application.
An application that makes available monikers that identify the objects it manages, so that the objects are accessible to other applications.
In COM, a programming structure encapsulating both data and functionality
that are defined for which the only public access is through the programming
A COM object must support, at a minimum, the
interface, which maintains the object's existence while
it is being used and provides access to the object's other interfaces.
COM and Interface.
The relationship between a compound document object in its container and the application responsible for the object's creation: active, passive, loaded, or running. Passive objects are stored on disk or in a database, and the object is not selected or active. In the loaded state, the object's data structures have been loaded into memory, but they are not available for operations such as editing. Running objects are both loaded and available for all operations. Active objects are running objects that have a visible user interface.
A server, implemented as an .EXE application, which runs outside the process of its client, either on the same machine or a remote machine. See alsoLocal server and Remote server.
A parameter that is allocated and freed by the caller, but its value is set by the function being called. See also In parameter and In/Out parameter.
The state of a COM object when it is stored (on disk or in a database). The object is not selected or active. See also Active state, Loaded state, Object state, and Running state.
Information that can be stored persistently as part of a storage object such as a file or directory. Persistent properties are grouped into property sets, which can be displayed and edited. Persistent properties are different from the run-time properties of objects created with ActiveX Controls and Automation technologies, which can be used to affect system behavior. The PROPVARIANT structure defines all valid types of persistent properties, whereas the VARIANT structure defines all valid types of run-time properties. See also Property, and Property sets.
Storage of a file or object in a medium such as a file system or database so that the object and its data persist when the file is closed and then re-opened at a later time.
A moniker that maps an interface pointer to an object in memory. Whereas most monikers identify objects that can be persistently stored, pointer monikers identify objects that cannot. They allow such objects to participate in a moniker binding operation.
A four-byte signed integer that identifies a persistent property within a property set. See also Persistent property and Property set.
A logically related group of properties that is associated with a persistently
To create, open, delete, or enumerate one or more property
sets, implement the
are using compound files, you can use COM's implementation of this interface
rather than implementing your own.
Property set storage
A COM storage object that holds a property set. A property set storage is a dependent object associated with and managed by a storage object. See alsoDependent object, Property set.
An interface-specific object that packages parameters for that interface in preparation for a remote method call. A proxy runs in the address space of the sender and communicates with a corresponding stub in the receiver's address space. See also Stub, Marshaling, and Unmarshaling.
In standard marshaling, a proxy that manages all the interface proxies for a single object. See also Marshaling, Proxy.
A portion of a larger object, such as a range of cells in a spreadsheet, that is represented as a distinct a COM object.
Keeping a count of each interface pointer held on an object to ensure that the object is not destroyed before all references to it are released. See alsoLock.
A moniker that specifies the location of an object relative to the location of another object. A relative moniker is analogous to a relative path, such as ..\backup\report.old. See also Moniker.
A server application, implemented as an EXE, running on a different machine from the client application using it. See also In-process server, Local server, and Out-of-process server.
To discard any changes made to an object since the last time the changes were committed or the object's storage was opened. See also Commit and Transacted access mode.
Root storage object
The outermost storage object in a document. A root storage object can contain other nested storage and stream objects. For example, a compound document is saved on disk as a series of storage and stream objects within a root storage object. See also Storage object, and Stream object.
The state of a COM object when its server application is running and it is possible to access its interfaces and receive notification of changes. See also Active state, Loaded state, Passive state.
Running Object Table (ROT)
A globally accessible table on each computer that keeps track of all COM objects in the running state that can be identified by a moniker. Moniker providers register an object in the table, which increments the object's reference count. Before the object can be destroyed, its moniker must be released from the table. See also Running state.
The process by which a server can perform its own registry operations.
See Advisory sink.
See Active state, Loaded state, Object state, Passive state, and Running state.
A COM object that implements the
A storage object contains nested storage objects or stream objects, resulting
in the equivalent of a directory/file structure within a single file.
Root storage object and Stream object.
A COM object that implements the
A stream object is analogous to a file in a directory/file system.
See also Storage object.
COM's technology for storing compound files in native file systems. See also Compound file, Storage object, and Stream object.
When a function's or interface method's parameters are marshaled across a process boundary, the stub is an interface-specific object that unpackages the marshaled parameters and calls the required method. The stub runs in the receiver's address space and communicates with a corresponding proxy in the sender's address space. See also Proxy, Marshaling, and Unmarshaling.
Manages all of the interface stubs for a single object.
See Dependent object.
A function call that does not allow further instructions in the calling process to be executed until the function returns. See also Asychronous call.
A system-wide repository of information supported by Windows, which contains information about the system and its applications, including COM clients and servers.
Information about an object's class provided by a type library.
type information, a COM object implements the
Uniform data transfer
A model for transferring data via the Clipboard, drag and drop, or Automation.
Objects conforming to this model implement the
See also Data transfer object.
Unpacking parameters that have been sent to a proxy across process boundaries.
Virtual Table (VTBL)
An array of pointers to interface method implementations. See also Interface.
See Lock .