The process of binding an object in order to put it into its running state. Also refers to invoking a particular operation on an object. See also Binding.

Absolute moniker

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

Advisory sink

An object that can receive notifications of changes in an embedded object or linked object because it implements the IAdviseSink interface (and possibly the IAdviseSink2 interface). Notifications originate in the object application, where they are cached in an advise holder, which passes them to advisory sinks implemented by object handlers. For an embedded object, the corresponding object handler forwards the notification to the object's container. For a linked object, the object handler forwards the notification to the link object, which in turn passes it on to the container. See also Object handler, Embedded object, Link object, Linked object, Container application.

Aggregate object

A component object that is made up of one or more other component objects. One object in the aggregate is designated the control object, which controls which interfaces in the aggregate are exposed and which are private. The control object has a special implementation of IUnknown called the controlling unknown. All non-controlling objects in the aggregate must pass calls to IUnknown methods through the controlling unknown.


A composition technique for implementing component objects. It allows you to build a new object with one or more existing objects that support some or all of the new object's required interfaces.


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. This is analogous to the way that ".." nullifies a directory component of a pathname (that is, \work\art\.. equals \work). 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 making a call that could result in its premature destruction by ensuring it won't be de-allocated. A process calls the AddRef method of IUnknown to increment the count before making the call that could otherwise free the object prematurely, and after the function returns, calls the IUnknown::Release method to decrement the count.

Asynchronous call

A function that allows the next instruction in the process to be executed as soon as the call is made, without waiting for the function to return. Most OLE functions and interface methods are synchronous; that is, the function must return before the next instruction is executed. OLE defines six asynchronous methods, five within the IAdviseSink interface pics/OLE00090000.gif OnDataChange, OnViewChange, OnRename, OnSave, and OnClose pics/OLE00090000.gif and one within the IAdviseSink2 interface pics/OLE00090000.gif OnLinkSourceChange.


See OLE Automation


Bind context

An object that implements the IBindCtx interface. Bind contexts are used in moniker operations. A bind context holds references to the objects activated when a moniker is bound, contains parameters that apply to all operations during the binding of a generic composite moniker, and provides the means by which the moniker implementation should retrieve information about its environment. See Binding, Moniker.


Generically, binding is the process of associating a name to its referent. When referring to monikers specifically, binding is the process of locating the object named by the moniker, activating it (loading it in memory) if it isn't already, and returning an interface pointer to it. Binding puts an object into its running state, allowing the operations it supports to be invoked. Objects can be bound at run time (also called late binding or dynamic binding) or at compile time (also called static binding). In OLE Automation, vtable-based binding is referred to as "early binding" and IDispatch-based binding is referred to as "late binding."



Generally, a cache is a (usually temporary) local store of information. In OLE, the term cache is used in connection with linked or embedded objects, in which the cache contains information that defines the presentation of a contained object when the container is opened.

Cache initialization

The process of filling an embedded object's cache with data formats. The IOleCache interface provides methods that a container object can call to control the data that gets cached for embedded objects.. The IOleCache::InitCache method fills the cache using data provided by a transfer from the Clipboard or from a drag-and-drop operation. The IOleCache::SetData method fills the cache using data in a storage object.


In object-oriented programming, a class is a set of objects whose behavior is defined by the same set of code (they share the same implementation).
A COM class is not necessarily the same as a class in an object-oriented language. A COM class can be identified by a CLSID, though for most COM operations, it is not necessary to know an object's class.

Class factory

A object that you use to create one or more instances of a an object identified by a given CLSID (class identifier). A class factory object implements the IClassFactory interface. A class factory is the most frequently used type of class object in OLE. See also CLSID.

Class identifier (CLSID)

A unique identification tag (UUID) associated with an OLE class object. A class object that is intended to create more than one object registers its CLSID in a task table in the registration database to enable clients to locate and load the executable code associated with the object(s). Every OLE object application (or container that allows linking to its embedded objects) must register a CLSID for each supported object definition.

Class object

In COM, class objects are called class factories, and typically have no behavior except to create new instances of the class. In object-oriented programming, an object whose state is shared by all the objects in a class, and whose behavior acts on that class-wide state data. See also Class factory.


In referring to OLE objects, an object that requests services from another object. See also Container.

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.


See Class identifier

Component object

An object that conforms to the OLE component object model (COM). Clients deal with a component object only through a pointer to an interface (a related set of functions called methods). With the pointer, clients can call the methods that perform operations or manipulate the data associated with the object. Component objects are instances of an object definition, which specifies an implementation of the interfaces on the object.

Composite moniker

A moniker that consists of two or more monikers composed together. 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 Generic composite moniker.


The act of persistently saving any changes made to an object since its storage was opened or since the last time changes were saved. See also Revert.

Component object model (COM)

The OLE object-oriented programming model that defines how objects interact within a single application or between applications. In COM, clients have access to an OLE object through a pointer to an interface (a related set of functions called methods) on the object.

Composite menu

A shared menu bar composed of menu groups from both an in-place container and an in-place object application. The object application must install and remove the menu from the container's frame window.

Compound document

A document that contains data of different formats, created by different applications. Compound documents are created in a container application, such as Word, and information from other applications (such as spreadsheets, sound clips, and bitmaps) is either embedded in or linked to the container application. When the compound document is saved, the container application saves it.

Compound file

An OLE-provided implementation of structured storage which includes the IStorage, the IStream, and the ILockBytes interfaces. You use a set of StgXxx API functions to create and use a compound file.


See Container application.

Container application

An application that supports compound documents. Container applications provide storage for the object, a site for display, access to the display site, and an advisory sink for receiving notifications of changes in the object. See also Compound document, Client site, and Advisory sink.


An application that has implemented OLE interfaces such that the application supports the features and capabilities of both a container and object application.


See Container/Object.

Control object

The object within an Aggregate object that controls which interfaces within the aggregate object are exposed and which are private.. The control object has a special implementation of IUnknown called the controlling unknown, and all other objects in the aggregate must pass calls to IUnknown methods through the controlling unknown. See Aggregate object.


Data transfer object

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

Default object handler

A DLL provided with the OLE SDK that provides a partial implementation of basic interfaces. It is 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 on behalf of a loaded object, such as rendering an object from its cached state when the object is loaded into memory.

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.

Drag and drop

OLE specifies a set of data transfer and drag-and drop-interface-specific interfaces that allow applications to implement drag and drop, an operation in which the end-user uses the mouse or other pointing device to drag data from one window and drop it into another location in the same window or into another window.


Embedded object

A compound-document object that is stored with the container application, but when it is running, lives in the process space of the server application, which creates and subsequently edits it. The default handler provides a surrogate in the processing space of the container application for the real object.

Explicit caching

One of two ways an object can cache its presentation data. Explicit caching requires the physical creation of the cache nodes needed to save the data formats of the object. See also Implicit caching.


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 an object that represents an implementation of the IMoniker interface for the file class. See also Item moniker and Generic composite moniker.


Global memory

See Shared application memory.

Generic composite moniker

The generic composite moniker is a sequenced collection of other types of monikers, starting with a file moniker to provide the document-level path and continuing with one or more item monikers. See also Item moniker and File moniker.



See Object handler.

Helper function

A function that encapsulates other functions and interface methods publicly available in the OLE SDK.


An opaque result handle defined to be zero for a successful return from a function and non-zero if error or status information is to be returned. To convert an HRESULT into the more detailed SCODE, applications call GetScode(). See SCODE.


Implicit caching

The "implied" caching of presentation data by an object that is capable of rendering itself using its native data. Cache nodes are not created with implicit caching. See also Explicit caching.

In parameter

A parameter that is allocated, set, and freed by the caller of a function.

In/Out parameter

A parameter that is initially allocated by the caller of a function and set, freed, and reallocated if necessary by that which is called.

In-process server

An object server or application implemented as a DLL that runs in the process space of the object's container. See also Local server, Remote server.


An object for which memory is allocated or which is persistent.


The process of creating an activating an obnect based on its definition.


A group of related functions that provide access to OLE objects. The set of OLE interfaces define a contract that allow 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 unique identification tag associated with each interface. Some functions take IIDs as parameters to allow the callers to specify what type of interface pointer should be returned.

Item moniker

A moniker based on a string that identifies an object in a container. Item monikers can be used to 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 and Generic composite moniker.


Link object

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

Linked object

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

Link source

The data that is the source of a linked compound document object. A link source may be a file or a portion of a file, such as an embedded object or a selected range within a file (also called a pseudo object).

Loaded state

The state of a compound-document object after its data structures have been loaded into container memory. The data structures are created by the object handler. See also Passive state and Running state.

Local server

An server application implemented as an EXE running on the same machine as the client application using it. Because the server application is an EXE, it runs in its own process. See also In-Process server and Remote server.


OLE defines two types of locks that can be held on an object: strong and weak. A strong lock will keep an object in memory, a weak lock will not.

LRPC (Lightweight remote procedure call)

OLE's RPC-based protocol for interprocess communication. LRPC is "lightweight" in that it handles communication between processes on one machine only.



The process of packaging and sending interface parameters across process boundaries.


An object that implements the IMoniker interface. A moniker acts as a name that uniquely identifies a COM object. You can think of a moniker as a generalization of a pathname; in the same way that a pathname identifies a file in the file system, a moniker identifies a COM object. Monikers support an operation known as "binding," which is the process of locating the object named by the moniker, activating it (loading it in memory) if it isn't already, and returning an interface pointer to it.

Moniker class

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

Moniker client

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

Moniker provider

An application that hands out monikers that identify the objects it manages, so that they are accessible to other applications.

Multiple Document Interface (MDI) Application

An application that can support multiple documents from one application instance. MDI object applications can simultaneously serve a user and one or more embedding containers. See also Single Document Interface (SDI) application.


Native data

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

Nested object

An OLE object that is embedded within another OLE object through the use of a combination container/server application. OLE objects can be arbitrarily nested to any level.



Generally, an instance of an entity that embodies both specific data and the functions that manipulate it.
Specifically in object-oriented programming, an object is an entity that has state, behavior and identity. An object's state consists of its attributes and and the attributes' current values. An object's behavior consists of the operations that can be performed on it and the accompanying state changes. An object's identity is what you use to distinguish it from other objects.
In contrast, COM objects' behavior is defined by the interfaces it supports. A COM object's state is not explicitly specified, but is implied by its interfaces. A COM object's identity is defined by the ability to use IUnknown::QueryInterface to move between interfaces.
A COM object follows a specific model in which clients (those using an object's services) gain access to the object's data only through a pointer to an interface consisting of a set of methods (related functions). The client can then call these methods to perform desired operations. There is no direct access to an OLE object's data.

Object application

An OLE-aware application that can create compound document objects. Containers can then embed or link to these objects.

Object handler

A piece of class-specific code that is dynamically loaded into the address space of its container. Object handlers process requests for specific classes of objects, so that much of the communication can be in-process. This is more efficient because it reduces the need for remote procedure calls.

Object state

One of three relationships between a compound document object in its container and the application responsible for the object's creation: passive, loaded, and running. Passive objects are stored (on disk or in a database), and the object is not selected or active. In the loaded state, its data structures have been loaded into memory, but is not yet available for operations such as editing. Running objects are both loaded and available for all operations.

Object type name

A unique identification string that is stored as part of the information available for an object in the registration databasepics/OLE00090000.giffor example, Acme Drawing.

OLE Automation

A way to manipulate an application's objects from outside the application. OLE 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. For information on OLE Automation, refer to the OLE Programmer's Reference, Volume 2.

Out parameter

A function parameter that is allocated and set by whatever a function calls, and must be freed by the caller.


Passive state

The state of an OLE object when it is stored (on disk or in a database). The object is not selected or active. See also Loaded state and Running state.

Persistent storage

Storage of a file or object in a medium such as a file system or database so that the file can be closed and then re-opened at a later time. Data can be retrieved from the file until the underlying file is deleted.

Pointer moniker

A moniker that wraps an interface pointer to an object in memory. Whereas most monikers identify objects that can be saved to persistent storage, pointer monikers identify objects that cannot. They allow such objects to participate in a moniker binding operation.

Presentation data

The data used by an OLE container applicationto display embedded or linked objects. See also Native data.

Primary verb

The action associated with the most common, 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.


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

Manages all the proxies for a single object.

Pseudo object

A selection of data within a document or embedded object that can be the source for a compound-document object.


Reference counting

Keeping a count of each interface pointer instance to ensure that an 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 pathname (such as "..\backup\report.old").

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.


The act of discarding any change(s) made to an object since the last time the changes were committed or the object's storage was opened. See also Commit, Transacted access mode.

Root IStorage object

The outermost IStorage instance in a document; also called the root storage object. Compound-document objects are always saved as children of a root IStorage object.

Running state

The state of an OLE object when the object application is running and it is possible to edit the object, access its interfaces, and receive notification of changes. See also Loaded state and Passive state.

Running object table (ROT)

A globally-accessible table on each machine that keeps track of all the OLE objects that can be identified by a moniker and are currently running on the machine. Monikers use the Running Object Table. Registering an object in the running object table increments the object's reference count. Before the object can be destroyed, its moniker must be released from the running object table.



A DWORD value that is used to pass detailed information to the caller of an interface method or function. See also HRESULT.


See Object application.

Shared application memory

Memory that is primarily used between processes to optimize the data copying that occurs in LPRC calls.

Single Document Interface (SDI) Application

An application that can support only one document at a time. Multiple instances of an SDI application must be started to service both an embedded object and a user. See also Multiple Document Interface (MDI) application.

Single object application

An application that is capable of creating and manipulating one class of object. See also Multiple object application.

Stand-alone object application

An object application implemented as an executable (EXE) program, rather than as a DLL object application.


See Loaded state, Passive state, and Running state.

Static object

An object that contains only a presentation, with no native data. A container application 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; you don't want the linked object to be updated anymore.

Storage object

An object that implements the IStorage interface. A storage object contains nested storage objects or stream objects, resulting in a directory/file system within a single file. It provides the underlying storage for compound documents. Container applications provide a nested storage object for each of their embedded objects. The embedded object stores its data nested storage and stream objects within the storage object provided by its container. See also Root IStorage object and Stream object.

Stream object

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

Structured storage model

A specification that defines a hierarchical method of storing objects. OLE provides an implementation of the structured storage model called Compound Files. See Compound file.


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 Proxy, Marshaling, and Unmarshaling.

Stub manager

Manages all of the stubs for a single object.

Synchronous call

A function that does not allow further instructions in the process to be executed until the function returns. Most OLE interface methods, except some of the IAdviseSink methods, are synchronous calls. See also Asychronous call.


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 temporary buffers until the root IStorage object commits its changes. See also Direct access mode, Commit, Revert.


Uniform data transfer

A model for transferring data via the Clipboard, drag and drop, or through automation. Objects conforming to the model implement the IDataObject interface. This model replaces DDE (dynamic data exchange). See Data transfer object.


The processing of unpackaging parameters that have been sent across process boundaries.


Virtual Table (VTBL)

An array of pointers that point to interface method implementations.

Visual Editing

A term in end-user documents that refers to the user's ability to interact with a compound-document object in the context of its container. The term most often used by developers is in-place activation. See also In-place activation.

Software for developers
Delphi Components
.Net Components
Software for Android Developers
More information resources
Unix Manual Pages
Delphi Examples