The process of loading an object in memory, which puts it into its running state. See also Binding.

Absolute moniker

A moniker that specifies the absolute location of an object. An absolute moniker is analogous to a full path. See also Moniker.

Advisory holder

A COM object that caches, manages, and sends notifications of changes to container applications' advisory sinks. See also Advisory sink.

Advisory sink

A COM object that can receive notifications of changes in an object because it implements the IAdviseSink or IAdviseSink2 interface. 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.

Aggregate object

A COM object that is made up of one or more other COM objects. One object in the aggregate is designated the controlling object, which controls which interfaces in the aggregate are exposed and which are private. This controlling object has a special implementation of IUnknown called the controlling IUnknown. All objects in the aggregate must pass calls to IUnknown methods through the controlling IUnknown. See also Aggregation.


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 IUnknown::AddRef to increment the object's reference count before making the call that could free the object. After the function returns, the program calls IUnknown::Release to decrement the count.

Asynchronous call

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.

Bind context

A COM object that implements the IBindCtx interface. 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 environment. See also Binding, Generic composite moniker, and 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.

Class factory

A COM object that implements the IClassFactory interface and that creates one or more instances of an object identified by a given class identifier(CLSID). 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.

Class object

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.

Composite moniker

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.

COM object

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.

Connectable object

A COM object that implements, at a minimum, the IConnectionPointContainer interface, for the management of connection point objects. Connectable objects support communication from the server to the client. A connectable 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. See also Connection point object and Advisory sink.

Connection point object

A COM object that is managed by a connectable object and that implements the IConnectionPoint interface. One or more connection point objects can be created and managed by a connectable object. Each connection 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.

Controlling object

The object within an aggregate object that controls which interfaces within the aggregate object are exposed and which are private. The IUnknown interface of the controlling object is called the controlling IUnknown. Calls to IUnknown methods of other objects in the aggregate must be passed to the controlling IUnknown. See also Aggregate object.

Data transfer object

An object that implements the IDataObject interface and contains data to be transferred from one object to another through either the Clipboard or drag-and-drop operations.

Dependent object

A COM object that is typically initialized by another object (the host object). 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 IUnknown for the dependent object. In contrast, an object is an aggregated object when its lifetime (by means of its reference count) is completely controlled by the managing object. See also Host 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.

.EXE server

See Out-of-process server.

File moniker

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 IMoniker interface for the file moniker class. See also Item moniker, Generic composite moniker, and Moniker.

Format identifier

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.

Helper function

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.

Host object

A COM object that forms a hierarchical relationship with one or more other COM objects, known as the dependent objects. Typically, 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 IUnknown for the dependent objects, nor does it directly delegate to the interface implementations of those objects. See also Dependent object.

In parameter

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.

In/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.

In-process server

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.

Item moniker

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. Licensed objects can be created only by clients that are authorized to use them. Licensing is implemented in COM through the IClassFactory2 interface and by support for a license key that can be passed at run time.

Link source

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.

Loaded state

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.

Local server

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 object. COM defines two types of locks that can be held on an object: strong and weak. 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 Release. 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 IMoniker interface. 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. See also Binding.

Moniker class

An implementation of the IMoniker interface. System-supplied moniker classes include file monikers, item monikers, generic composite monikers, anti-monikers, pointer monikers, and URL monikers.

Moniker client

An application that uses monikers to acquire interface pointers to objects managed by another application.

Moniker provider

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 structure's interfaces. A COM object must support, at a minimum, the IUnknown interface, which maintains the object's existence while it is being used and provides access to the object's other interfaces. See also COM and Interface.

Object state

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.

Out-of-process server

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.

Out parameter

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.

Passive state

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.

Persistent properties

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.

Persistent storage

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.

Pointer moniker

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.

Property identifier

A four-byte signed integer that identifies a persistent property within a property set. See also Persistent property and Property set.

Property set

A logically related group of properties that is associated with a persistently stored object. To create, open, delete, or enumerate one or more property sets, implement the IPropertySetStorage interface. If you are using compound files, you can use COM's implementation of this interface rather than implementing your own. See also Persistent properties.

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.

Proxy manager

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.

Reference counting

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.

Relative moniker

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.

Remote Server

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.

Running state

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.

Storage object

A COM object that implements the IStorage interface. A storage object contains nested storage objects or stream objects, resulting in the equivalent of a directory/file structure within a single file. See also Root storage object and Stream object.

Stream object

A COM object that implements the IStream interface. A stream object is analogous to a file in a directory/file system. See also Storage object.

Strong lock

See Lock.

Structured Storage

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.

Stub manager

Manages all of the interface stubs for a single object.


See Dependent object.

Synchronous call

A function call that does not allow further instructions in the calling process to be executed until the function returns. See also Asychronous call.

System registry

A system-wide repository of information supported by Windows, which contains information about the system and its applications, including COM clients and servers.

Type information

Information about an object's class provided by a type library. To provide type information, a COM object implements the IProvideClassInfo interface.

Uniform data transfer

A model for transferring data via the Clipboard, drag and drop, or Automation. Objects conforming to this model implement the IDataObject interface. 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.

Weak lock

See Lock .