MSDN Documentation

Introduction to COM

Welcome to the introduction to Component Object Model (COM). This guide provides a foundational understanding of COM, its architecture, and its significance in Windows development.

What is COM?

The Component Object Model (COM) is a binary-interface standard for developing reusable software components. It enables the creation of applications and components that can interact with each other, regardless of the programming language they were written in, as long as they adhere to the COM standard. COM is a cornerstone of many Windows technologies and has been instrumental in building complex and extensible software systems.

Key Concepts

Understanding COM involves grasping several fundamental concepts:

• Components: Self-contained units of functionality that expose interfaces.
• Interfaces: A contract that defines a set of functions (methods) that a component supports. Interfaces are abstract and language-independent.
• Objects: Instances of components that implement one or more interfaces.
• GUIDs (Globally Unique Identifiers): Used to uniquely identify interfaces and components.
• Registries: System databases where COM components register their presence and location.

Benefits of COM

COM offers several advantages for software development:

• Reusability: Components can be reused across different applications.
• Language Independence: Components can be written in various languages (C++, VB, Delphi) and still interact.
• Extensibility: New versions of components can be introduced without breaking existing applications.
• Interoperability: Enables communication between different parts of an application or between different applications.
• In-Process and Out-of-Process: COM supports both in-process (in the same process as the caller) and out-of-process (in a separate process) communication.

COM Interfaces

An interface in COM is a collection of related function declarations. It defines the what but not the how. Components implement these interfaces to provide their functionality. The most fundamental interface is IUnknown, which all COM interfaces derive from. IUnknown provides three essential methods:

• QueryInterface: Allows a client to query for other interfaces supported by an object.
• AddRef: Increments the reference count of an object.
• Release: Decrements the reference count of an object.

Another crucial interface is IDispatch, which enables late binding and automation.

COM Objects

A COM object is an instance of a COM component. It encapsulates data and behavior and exposes its functionality through one or more interfaces. When you create a COM object, you obtain a pointer to one of its interfaces. You then use this pointer to call the methods defined by the interface.

Reference Counting

COM uses a mechanism called reference counting to manage the lifetime of objects. Every COM object maintains a reference count. When a client obtains a pointer to an interface, it calls AddRef to increment the count. When the client is finished with the interface pointer, it calls Release to decrement the count. The COM object is destroyed automatically when its reference count reaches zero.

Error Handling

COM defines a standard way of reporting errors using HRESULT values. These are 32-bit values that indicate success or failure. The caller is responsible for checking the HRESULT returned by each COM method call.

    HRESULT hr = pMyObject->MyMethod();
    if (FAILED(hr)) {
        // Handle the error
        wprintf(L"Error calling MyMethod: 0x%X\n", hr);
    }
                

Next Steps

This introduction covers the basic principles of COM. To delve deeper, consider exploring:

• The COM IDL (Interface Definition Language)
• COM registration and activation
• ATL (Active Template Library) and WRL (Windows Runtime C++ Template Library)
• COM+ services

Continue to the COM Interfaces section for a more detailed look at interface design and usage.