Interfaces (COM)
The following interfaces are provided by COM.
Interface | Description |
---|---|
IAccessControl | Enables the management of access to objects and properties on the objects. |
IAgileObject | Marks an interface as agile across apartments. |
IBindCtx | Provides access to a bind context, which is an object that stores information about a particular moniker binding operation. |
IBlockingLock | Provides a semaphore that can be used to provide temporarily exclusive access to a shared resource such as a file. |
ICallFactory | Creates a call object for processing calls to the methods of an asynchronous interface. |
ICallFrame | Enables manipulation of call frames such as stack frames. The call frame is the body of information that a procedure must save to allow it to properly return to its caller. A call frame may exist on the stack or in registers. A stack frame maintains its caller's context information on the stack. |
ICallFrameEvents | Delivers method call notifications. |
ICallFrameWalker | Walks a stack frame looking for interesting values. |
ICallIndirect | Invokes an object with an indirect reference to the invocations arguments, rather than the traditional direct call. |
ICallInterceptor | Supports the registration and un-registering of event sinks wishing to be notified of calls made directly on the interface. In addition, this interface provides a means by which an invocation can be carried out with an indirect reference to the invocations arguments. |
ICallUnmarshal | Is used on the server (receiving) side of a remote invocation. An appropriate instance of ICallUnmarshal can be used to transform back into an call frame a method invocation previously marshaled by a call to ICallFrame::Marshal on the client (sending) side. |
ICancelMethodCalls | Manages cancellation requests on an outbound method call and monitors the current state of that method call on the server thread. |
ICatInformation | Obtains information about the categories implemented or required by a certain class, as well as information about the categories registered on the specified computer. |
ICatRegister | Provides methods for registering and unregistering component category information in the registry. This includes both the human-readable names of categories and the categories implemented/required by a given component or class. |
IClassActivator | Specifies a method that retrieves a class object. |
IClassFactory | Enables a class of objects to be created. |
IClassFactory2 | Enables a class factory object, in any sort of object server, to control object creation through licensing. |
IClientSecurity | Gives the client control over the security settings for each individual interface proxy of an object. |
IComThreadingInfo | Enables you to obtain the following information about the apartment and thread that the caller is executing in: apartment type, thread type, and thread GUID. It also allows you to specify a thread GUID. |
IConnectionPoint | Supports connection points for connectable objects. |
IConnectionPointContainer | Supports connection points for connectable objects. |
IContext | Supports setting COM+ context properties. |
IContextCallback | Provides a mechanism to execute a function inside a specific COM+ object context. |
IContinueCallback | Provides a generic callback mechanism for interruptible processes that should periodically ask an object whether to continue. |
IEnumCATID | Enumerates category identifiers. |
IEnumCLSID | Enumerates class identifiers. |
IEnumCATEGORYINFO | Enumerates component categories registered in the system. |
IEnumConnectionPoints | Enumerates connection points. |
IEnumConnections | Enumerates the current connections for a connectable object. |
IEnumContextProps | Provides a mechanism for enumerating the context properties associated with a COM+ object context. |
IEnumGUID | Enables clients to enumerate through a collection of class IDs for COM classes. |
IEnumString | Enumerate strings. LPWSTR is the type that indicates a pointer to a zero-terminated string of wide, or Unicode, characters. |
IEnumUnknown | Enumerates objects with the IUnknown interface. It can be used to enumerate through the objects in a component containing multiple objects. |
IEventProperty | Associates a named event property with its value. |
IEventPublisher | Registers, modifies, removes, and provides information about an event publisher. |
IExternalConnection | Manages a server object's count of marshaled, or external, connections. A server that maintains such a count can detect when it has no external connections and shut itself down in an orderly fashion. |
IFastRundown | Marks an interface as eligible for fast rundown behavior. |
IFileBasedLogInit | Initializes an instance of a file based implementation of ILog. |
IForegroundTransfer | Transfers the foreground window to the process hosting the COM server. |
IGlobalInterfaceTable | Enables any apartment in a process to get access to an interface implemented on an object in any other apartment in the process. |
IGlobalOptions | Sets and queries certain global properties of the COM runtime. |
IInitializeSpy | Performs initialization or cleanup when entering or exiting a COM apartment. |
IInternalUnknown | Used exclusively in lightweight client-side handlers that require access to some of the internal interfaces on the proxy. |
ILog | Provides generic low-level logging functionality. |
IMalloc | Allocates, frees, and manages memory. |
IMallocSpy | Enables application developers to monitor (spy on) memory allocation, detect memory leaks, and simulate memory failure in calls to IMalloc methods. |
IMarshal | Enables a COM object to define and manage the marshaling of its interface pointers. |
IMarshalingStream | Provides additional information about the marshaling context to custom-marshaled objects and unmarshalers. |
IMessageFilter | Provides COM servers and applications with the ability to selectively handle incoming and outgoing COM messages while waiting for responses from synchronous calls. Filtering messages helps to ensure that calls are handled in a manner that improves performance and avoids deadlocks. COM messages can be synchronous, asynchronous, or input-synchronized; the majority of interface calls are synchronous. |
IMoniker | Enables you to use a moniker object, which contains information that uniquely identifies a COM object. An object that has a pointer to the moniker object's IMoniker interface can locate, activate, and get access to the identified object without having any other specific information on where the object is actually located in a distributed system. |
IMultiQI | Enables a client to query an object proxy, or handler, for multiple interfaces by using a single RPC call. By using this interface, instead of relying on separate calls to IUnknown::QueryInterface, clients can reduce the number of RPC calls that have to cross thread, process, or machine boundaries and, therefore, the amount of time required to obtain the requested interface pointers. |
IObjContext | Performs various operations on contexts. |
IOleItemContainer | Used by item monikers when they are bound to the objects they identify. |
IOrpcDebugNotify | Provides remote debugging functionality. |
IParseDisplayName | Parses a displayable name string to convert it into a moniker for custom moniker implementations. |
IPersist | Provides the CLSID of an object that can be stored persistently in the system. Allows the object to specify which object handler to use in the client process, as it is used in the default implementation of marshaling. |
IPersistFile | Enables an object to be loaded from or saved to a disk file, rather than a storage object or stream. |
IPersistStorage | Enables a container application to pass a storage object to one of its contained objects and to load and save the storage object. |
IPersistStream | Enables the saving and loading of objects that use a simple serial stream for their storage needs. |
IPersistStreamInit | A replacement for IPersistStream that adds an initialization method. |
IPipeByte | Transfers data of the byte type (which is 8 bits wide). |
IPipeDouble | Transfers data of the double type (which is 64 bits wide). |
IPipeLong | Transfers data of the long integer type (which is 32 bits wide). |
IProcessInitControl | Specifies the process initialization time-out interval. |
IProcessLock | Used by ISurrogateService to prevent the process from terminating due to a time-out. |
IProgressNotify | Enables applications and other objects to receive notifications of changes in the progress of a downloading operation. |
IProvideClassInfo | Provides access to the type information for an object's coclass entry in its type library. |
IProvideClassInfo2 | An extension to IProvideClassInfo that makes is faster and easier to retrieve an object's outgoing interface IID for its default event set. |
IProvideMultipleClassInfo | An extension to IProvideClassInfo2 that makes it faster and easier to retrieve type information from a component that may have multiple coclasses that determine its behavior. |
IPSFactoryBuffer | Provides custom methods for the creation of COM object proxies and stubs. This interface is not marshalable. |
IROTData | Implemented by monikers to enable the running object table (ROT) to compare monikers against each other. |
IRpcChannelBuffer | Marshals data between a COM client proxy and a COM server stub. |
IRpcOptions | Enables callers to set or query the values of various properties that control how COM handles remote procedure calls (RPC). |
IRpcProxyBuffer | Controls the RPC proxy used to marshal data between COM components. |
IRpcStubBuffer | Controls the RPC stub used to marshal data between COM components. |
IRunnableObject | Enables a container to control the running of its embedded objects. In the case of an object implemented with a local server, calling the Run method launches the server's .EXE file. In the case of an object implemented with an in-process server, calling Run causes the object .DLL file to transition into the running state. |
IRunningObjectTable | Manages access to the running object table (ROT), a globally accessible look-up table on each workstation. A workstation's ROT keeps track of those objects that can be identified by a moniker and that are currently running on the workstation. When a client tries to bind a moniker to an object, the moniker checks the ROT to see if the object is already running; this allows the moniker to bind to the current instance instead of loading a new one. |
IServerSecurity | Used by a server to help authenticate the client and to manage impersonation of the client. |
IStdMarshalInfo | Retrieves the CLSID identifying the handler to be used in the destination process during standard marshaling. |
ISurrogate | Used to dynamically load new DLL servers into an existing surrogate and free the surrogate when it is no longer needed. |
ISurrogateService | Used to initialize, launch, and release a COM+ application. You can also refresh the catalog and shut down the process. |
ISynchronize | Provides asynchronous communication between objects about the occurrence of an event. Objects that implement ISynchronize can receive indications that an event has occurred, and they can respond to queries about the event. In this way, clients can make sure that one request has been processed before they submit a subsequent request that depends on completion of the first one. |
ISynchronizeContainer | Manages a group of unsignaled synchronization objects. |
ISynchronizeEvent | Assigns an event handle to a synchronization object. |
ISynchronizeHandle | Retrieves a handle associated with a synchronization object. |
IUnknown | Enables clients to get pointers to other interfaces on a given object through the QueryInterface method, and manage the existence of the object through the AddRef and Release methods. All other COM interfaces are inherited, directly or indirectly, from IUnknown. Therefore, the three methods in IUnknown are the first entries in the VTable for every interface. |