COM Glossary


The process of loading an object in memory, which puts it into the running state.

active state

A COM object that is in the running state and has a visible user interface.

absolute moniker

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

advisory holder

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

advisory sink

A COM object that can receive notifications of changes in an embedded object or linked 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.

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.


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.

ambient property

A run-time property that is managed and exposed by the container. Typically, an ambient property represents a characteristic of a form, such as background color, that needs to be communicated to a control so that the control can assume the look and feel of its surrounding environment.


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.

artificial reference counting

A technique used to help protect 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 binding

A type of binding in which it is necessary for the process to occur asynchronously to avoid performance degradation for the end user. Typically, asynchronous binding is used in distributed environments such as the World Wide Web. OLE supports asynchronous moniker classes and callback mechanisms that allow the process of locating and initializing an object in a distributed environment to occur while other operations are being carried out.

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.

asynchronous moniker

A moniker that supports asynchronous binding. For example, instances of the system-supplied URL moniker class are asynchronous monikers.


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.


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).


A (usually temporary) local store of information. In OLE, a cache contains information that defines the presentation of a linked or embedded object when the container is opened.

cache initialization

Filling a linked or embedded object's cache with presentation data. The IOleCache interface provides methods that a container can call to control the data that gets cached for linked or embedded objects.


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 OLE can be coded in any language, class is used to refer to the general object definition.

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).

class identifier (CLSID)

A globally unique identifier (GUID) associated with an OLE 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 OLE server or container that allows linking to its embedded objects must register a CLSID for each supported object definition.

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.


A COM object that requests services from another object.

client site

The display site for an embedded or linked object within a compound document. The client site is the principal means by which an object requests services from its container.


A globally unique identifier (GUID) associated with an OLE 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 OLE server or container that allows linking to its embedded objects must register a CLSID for each supported object definition.


To persistently save any changes made to a storage or stream object since it was opened or changes were last saved.


An object that encapsulates both data and code, and provides a well-specified set of publicly available services.

Component Object Model (COM)

The OLE 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.

composite menu bar

A shared menu bar composed of menu groups from both a container application and an in-place-activated server application.

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

compound document

A document that includes linked or embedded objects, as well as its own native data.

compound file

An OLE-provided Structured Storage implementation.

COM object

An object that conforms to the OLE 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.

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.

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.

container application

An application that supports compound documents. The container application provides storage for an embedded or linked object, a site for its display, access to the display site, and an advisory sink for receiving notifications of changes in the object.


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.


In COM+, a set of run-time properties associated with one or more COM objects that are used to provide services for those objects.


An embeddable, reusable COM object that supports, at a minimum, the IOleControl interface. Controls are typically associated with the user interface. They also support communication with a container and can be reused by multiple clients, depending upon licensing criteria.

control container

An application that supports embedding of controls by implementing the IOleControlSite interface.

control property

A run-time property that is exposed and managed by the control itself. For example, the font and text size used by the control are control properties.

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.

control site

A structure implemented by a control container for managing the display and storage of a control. Within a given container, each control has a corresponding control site.

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.

default object handler

A DLL provided with OLE that acts as a surrogate in the processing space of the container application for the real object.

With the default object handler, it is possible to look at an object's stored data without actually activating the object. The default object handler performs other tasks, such as rendering an object from its cached state when the object is loaded into memory.

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.

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.

document object

An OLE document that can display one or more in-place activated views of its data within a native or foreign frame, such as a browser, while retaining full control over its user interface. In addition to implementing the usual OLE document and in-place activation interfaces, a document object must implement IOleDocument, and each of its views (in the form of a document view object) must implement IOleDocumentView.

document object container

A container application capable of displaying one or more views of one or more document objects and of managing all contained document objects within a file. Each document object is associated with a document site, and each document site contains one or more document view sites corresponding to the views supported by the document object. A document object container also includes a container frame, which handles menu and toolbar negotiation and the enumeration of contained objects.

document object server

A server application capable of providing document objects.

document site

A client site implemented by a document object container for managing the display and storage of a document object. Each document object in a container has a corresponding document site.

document site object

A COM object that implements the IOleDocumentSite interface, in addition to the usual client-site interfaces (such as IOleClientSite).

document view

A particular presentation of a document's data. A single document object can have one or more views, but a single document view can belong to one and only one document object.

document view object

A COM object that implements the IOleDocumentView interface and corresponds to a particular document view. An object with multiple document views aggregates a separate document view object for each view.

document view site

An object aggregated by a document site object for managing the display space for a particular view of a document object. Within a given document site, each document view has a corresponding document view site.

document view site object

A COM object that is aggregated in a document site object and implements the IOleInPlaceSite interface and, optionally, the IContinueCallback interface.

drag and drop

An operation in which the end user uses the mouse or other pointing device to move data to another location in the same window or another window.


To insert an object into a compound document in such a way as to preserve the data formats native to that object, and to enable it to be edited from within its container using tools exposed by its server.

embedded object

An object whose data is stored in a compound document, but the object runs in the process space of its server. The default object handler provides a surrogate in the processing space of the container application for the real object.

extended property

A run-time property, such as a control's position and size, that a user would assume to be exposed by the control but is exposed and managed by the container.

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.

font object

A COM object that provides access to Graphics Device Interface (GDI) fonts by implementing the IFont interface.

format identifier

A GUID that identifies a persistent property set. Also referred to as FMTID.


The part of a container application responsible for negotiating menus, accelerator keys, toolbars, and other shared user-interface elements with an embedded COM object or a document object.

frame object

A COM object that implements the IOleInPlaceFrame interface and, optionally, the IOleCommandTarget interface.

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.

helper function

A function that encapsulates calls to other functions and interface methods publicly available in the OLE SDK. 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.


An opaque result handle defined to be zero for a successful return from a function and nonzero if error or status information is returned.

hyperlink object

A COM object that implements, at a minimum, the IHlink interface and acts as a link to an object at another location (the target). A hyperlink is made up of four parts: a moniker that identifies the target's location; a string for the location within the target; a friendly, or displayable, name for the target; and a string that can contain additional parameters.

hyperlink browse context

A COM object that implements the IHlinkBrowseContext interface and maintains the hyperlink navigation stack. The browse context object manages the hyperlink frame window and hyperlink target object's window.

hyperlink container

A container application that supports hyperlinks by implementing the IHlinkSite interface and, if the container's objects can be targets of other hyperlinks, the IHlinkTarget interface.

hyperlink frame object

A COM object that implements the IHlinkFrame interface and controls the top-level navigation and display of hyperlinks for the frame's container and the hyperlink target's server.

hyperlink site object

A COM object that implements the IHlinkSite interface and supplies either the moniker or interface identifier of its hyperlink container. One hyperlink site can serve multiple hyperlinks.

hyperlink target object

A COM object that implements the IHlinkTarget interface and supplies its moniker, friendly name, and other information that other hyperlink objects will use to navigate to it.

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.

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.

in-place activation

Editing an embedded object within the window of its container, using tools provided by the server. Linked objects do not support in-place activation; they are always edited in the window of the server.

in-process server

A server implemented as a DLL that runs in the process space of the client.


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 OLE interface defines a contract that allows objects to interact according to the Component Object Model (COM). While OLE provides many interface implementations, most interfaces can also be implemented by developers designing OLE applications.

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).


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 object

A COM object that is created when a linked COM object is created or loaded. The link object is provided by OLE and implements the IOleLink interface.

linked object

A COM object whose source data physically resides where it was initially created. Only a moniker that represents the source data and the appropriate presentation data are kept with the compound document. Changes made to the link source are automatically reflected in the linked object.

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).

loaded state

The state of an object after its data structures have been loaded into memory and are accessible to the client process.

local server

An out-of-process server implemented as an .EXE application running on the same computer as its client application.


A pointer held to-and possibly, a reference count incremented on-a running object. OLE 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 IUnknown::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.

media type

An extension of MIME that allows data format negotiation between a client and an object.

MIME content type

An extension of MIME that allows data format negotiation between a client and an object.

Multipurpose Internet Mail Extension (MIME)

An Internet protocol originally developed to allow exchange of electronic mail messages with rich content across heterogeneous network, computer, and email environments. In practice, MIME has also been adopted and extended by non-mail applications.


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.

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.

namespace extension

An in-process COM object that implements IShellFolder, IPersistFolder, and IShellView, which are sometimes referred to as the namespace extension interfaces. A namespace extension is used either to extend the shell's namespace or to create a separate namespace. Primary users are the Windows Explorer and common file dialog boxes.

native data

The data used by an OLE server application when editing an embedded object.


In OLE, a programming structure encapsulating both data and functionality that are defined and allocated as a single unit and 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.

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.

object type name

A unique identification string that is stored as part of the information available for an object in the registration database.


Microsoft's object-based technology for sharing information and services across process and computer boundaries.

out-of-process server

A server, implemented as an .EXE application, which runs outside the process of its client, either on the same computer or a remote computer.

out parameter

An out parameter is allocated by the function being called, and freed by caller.

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.

persistent property

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.

A persistent property is different from the run-time properties of objects created with OLE 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.

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.

picture object

A COM object that provides access to GDI images by implementing the IPicture interface.

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.

presentation data

The data used by a container to display embedded or linked objects.

primary verb

The action associated with the most common or preferred operation users perform on an object. The primary verb is always defined as verb zero in the system registration database. An object's primary verb is executed by double-clicking on the object.


Information that is associated with an object. In OLE, properties fall into two categories: run-time properties and persistent properties. Run-time properties are typically associated with control objects or their containers. For example, background color is a run-time property set by a control's container. Persistent properties are associated with stored objects.

property frame

The user interface mechanism that displays one or more property pages for a control. The OLE Controls run-time system provides a standard implementation of a property frame that can be accessed by using the OleCreatePropertyFrame helper function.

property identifier

A four-byte signed integer that identifies a persistent property within a property set.

property page

A COM object with its own CLSID that is part of a user interface, implemented by a control, and allows the control's properties to be viewed and set. Property page objects implement the IPropertyPage interface.

property page site

The location within a property frame where a property page is displayed. The property frame implements the IPropertyPageSite interface, which contains methods to manage the sites of each of the property pages supplied by a control.

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 OLE'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.

property sheet

A set of property pages for one or more objects.


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.

proxy manager

In standard marshaling, a proxy that manages all the interface proxies for a single object.

pseudo object

A portion of a document or embedded object, such as a range of cells in a spreadsheet, that can be the source for 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.

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.

remote server

A server application, implemented as an EXE, running on a different computer from the client application using it.


To discard any changes made to an object since the last time the changes were committed or the object's storage was opened.

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.

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.

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.

run-time property

Discrete state information associated with a control object or its container. There are three types of run-time properties: ambient properties, control properties, and extended properties.


The process by which a server can perform its own registry operations.

server application

An application that can create COM objects. Container applications can then embed or link to these objects.

static object

An object that contains only a presentation, with no native data. A container can treat a static object as though it were a linked or embedded object, except that it is not possible to edit a static object.

A static object can result, for example, from the breaking of a link on a linked object-that is, the server application is unavailable, or the user doesn't want the linked object to be updated anymore.

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.

stream object

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

Structured Storage

OLE's technology for storing compound files in native file systems.


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.

stub manager

Manages all of the interface stubs for a single object.

synchronous call

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

system registry

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

transacted access mode

One of two access modes in which a storage object can be opened. When opened in transacted mode, changes are stored in buffers until the root storage object commits its changes.

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 through the clipboard, drag and drop, or Automation. Objects conforming to this model implement the IDataObject interface. This model replaces DDE (dynamic data exchange).


Unpacking parameters that have been sent to a proxy across process boundaries.

universal resource locator (URL)

The identifier used by the World Wide Web for the names and locations of objects on the Internet. OLE provides a moniker class, URL moniker, whose implementation can be used to bind a client to objects identified by a URL.

URL moniker

A moniker based on a universal resource locator (URL). A client can use URL monikers to bind to objects that reside on the Internet. The system-supplied URL moniker class supports both synchronous and asynchronous binding.